static void Main(string[] args) { //Connecting the reader and setting base parameters Reader r = Reader.Create("tmr:///COM3"); r.Connect(); r.ParamSet("/reader/region/id", Reader.Region.NA); //Region r.ParamSet("/reader/radio/readPower", 2000); //Read power r.ParamSet("/reader/gen2/t4", 3000); //3ms continuous wave //Defining the Select command to the tag Gen2.Select tempSelect = new Gen2.Select(false, Gen2.Bank.USER, 0xE0, 0, new byte[0]); //Storing Temperature data in reserved memory bank pointed at 0xE TagOp tempRead = new Gen2.ReadData(Gen2.Bank.RESERVED, 0xE, 1); SimpleReadPlan readPlan = new SimpleReadPlan(new int[] { 1 }, TagProtocol.GEN2, tempSelect, tempRead, 100); r.ParamSet("/reader/read/plan", readPlan); TagReadData[] tempReadResults = r.Read(75); //Read for 75ms foreach (TagReadData result in tempReadResults) { string EPC = result.EpcString; string frequency = result.Frequency.ToString(); string tempCodeHex = ByteFormat.ToHex(result.Data, ", "); int tempCode = Convert.ToInt32(tempCodeHex, 16); if (tempCode > 1000 && tempCode < 3500) { Console.WriteLine("EPC: " + EPC + "Frequency(kHz): " + frequency + "Temperature Code: " + tempCode); } } }
/// <summary> /// Read tag memory for readers or modules other the M5e variants /// </summary> /// <param name="bank">Gen2 memory bank</param> /// <param name="filter">filter</param> /// <param name="MemData">Data read from tag memory</param> private void ReadMemoryM6eVariants(Gen2.Bank bank, TagFilter filter, ref ushort[] MemData) { try { // Read tag memory with zero as start address and lenght of words to read as zero TagOp op = new Gen2.ReadData(bank, 0, 0); MemData = (ushort[])objectReader.ExecuteTagOp(op, filter); if (MemData.Length < 64) { // If data read is less then 64 words, then perform read word by word to make sure // all the data is read from the tag memory ReadTagMemoryWordByWord(bank, filter, ref MemData); } else { // If data read is more then 64 words then perform read with start address as 64 words // and length as zero ReadLargeTagMemory(bank, filter, ref MemData); } } catch (Exception ex) { if ((ex is FAULT_PROTOCOL_BIT_DECODING_FAILED_Exception) || ((ex is FAULT_NO_TAGS_FOUND_Exception))) { // Perform read when the tag has mem more then 128 bytes and doesn't support // Zero start address and number of words to read as zero ReadLargeTagMemoryWithoutZeroLengthSupport(bank, filter, ref MemData); } else { throw; } } }
public string ReadPassword(uint byteIndex, uint length) { try { DateTime timeBeforeRead = DateTime.Now; byte[] data = null; using (Reader reader = Reader.Create("tmr:///" + Vars.comport.ToLower())) { reader.Connect(); TagOp tagOp = new Gen2.ReadData(Gen2.Bank.RESERVED, byteIndex, (byte)length); SimpleReadPlan plan = new SimpleReadPlan(null, TagProtocol.GEN2, null, tagOp, 1000); reader.ParamSet("/reader/read/plan", plan); data = reader.ReadTagMemBytes(tagData, (int)Gen2.Bank.RESERVED, (int)byteIndex, (int)length); } DateTime timeAfterRead = DateTime.Now; TimeSpan timeElapsed = timeAfterRead - timeBeforeRead; commandTotalTimeTextBox.Text = timeElapsed.TotalSeconds.ToString(); return(ByteFormat.ToHex(data)); } catch (Exception ex) { MessageBox.Show(ex.Message); return(""); } }
public bool CheckAccessPasswordIsLocked() { try { string reservedBankData = string.Empty; //Read access password var op = new Gen2.ReadData(Gen2.Bank.RESERVED, 2, 2); var reservedData = (ushort[])_reader.ExecuteTagOp(op, null); if (null != reservedData) { reservedBankData = ByteFormat.ToHex(ByteConv.ConvertFromUshortArray(reservedData), "", " "); } var accessPassword = reservedBankData.Trim(' '); return(false); } catch (Exception ex) { if (ex is FAULT_GEN2_PROTOCOL_MEMORY_LOCKED_Exception) { return(true); } Trace.TraceError("Error checking access password. " + ex.Message + ex.StackTrace); return(false); } }
/// <summary> /// Read tag memory word by word. If FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception /// or Non-specific reader error or General Tag Error or Tag data access failed exception /// is received. Memory reading is stopped and the already read data is returned /// </summary> /// <param name="bank">Gen2 memory bank</param> /// <param name="filter">Select filter</param> /// <param name="data">Read tag memory data is returned</param> private void ReadTagMemoryWordByWord(Gen2.Bank bank, TagFilter filter, ref ushort[] data) { lock (new Object()) { List <ushort> dataTemp = new List <ushort>(); uint startaddress = 0; if (data != null) { // if the data variable already contains the data, then add that data // to data temp and change the start address to total data length dataTemp.AddRange(data); startaddress = (uint)data.Length; } int words = 1; TagOp op; bool isAllDataReceived = false; while (false == isAllDataReceived) { try { // Read tag memory word by word op = new Gen2.ReadData(bank, startaddress, Convert.ToByte(words)); dataTemp.AddRange(((ushort[])objectReader.ExecuteTagOp(op, filter))); startaddress += 1; } catch (Exception exception) { if (exception is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception || (-1 != exception.Message.IndexOf("Non-specific reader error")) || (-1 != exception.Message.IndexOf("General Tag Error")) || (-1 != exception.Message.IndexOf("Tag data access failed")) || (exception.Message.Contains("Tag memory overrun error") || (exception.Message.Contains("Gen2 unspecific error")))) { if (dataTemp.Count > 0) { // Just skip the exception and move on. So as not to lose the already read data. isAllDataReceived = true; } else { // throw the exception if the data received is null for the first iteration itself throw; } } else { throw; } } } data = dataTemp.ToArray(); } }
public static string SaveSimpleReadPlan(Object value) { string readPlan = string.Empty; ReadPlan rp = (ReadPlan)value; readPlan += "SimpleReadPlan:["; SimpleReadPlan srp = (SimpleReadPlan)rp; readPlan += "Antennas=" + ArrayToString(srp.Antennas); readPlan += "," + "Protocol=" + srp.Protocol.ToString(); if (srp.Filter != null) { if (srp.Filter is Gen2.Select) { Gen2.Select sf = (Gen2.Select)srp.Filter; readPlan += "," + string.Format("Filter=Gen2.Select:[Invert={0},Bank={1},BitPointer={2},BitLength={3},Mask={4}]", (sf.Invert?"true" : "false"), sf.Bank, sf.BitPointer, sf.BitLength, ByteFormat.ToHex(sf.Mask)); } else { Gen2.TagData td = (Gen2.TagData)srp.Filter; readPlan += "," + string.Format("Filter=TagData:[EPC={0}]", td.EpcString); } } else { readPlan += ",Filter=null"; } if (srp.Op != null) { if (srp.Op is Gen2.ReadData) { Gen2.ReadData rd = (Gen2.ReadData)srp.Op; readPlan += "," + string.Format("Op=ReadData:[Bank={0},WordAddress={1},Len={2}]", rd.Bank, rd.WordAddress, rd.Len); } else { readPlan += ",Op=null"; } } else { readPlan += ",Op=null"; } readPlan += "," + "UseFastSearch=" + srp.UseFastSearch.ToString(); readPlan += "," + "Weight=" + srp.Weight.ToString() + "]"; return(readPlan); }
// read multiple registers from one tag singulated by its EPC public static short[] ReadMemBlockByEpc(Reader reader, TagReadData tag, Gen2.Bank bank, int address, int length, int attempts) { Gen2.Select resetFilter = CreateGen2Select(4, 4, Gen2.Bank.TID, 0x00, 16, new byte[] { 0xE2, 0x82 }); Gen2.Select epcFilter = CreateGen2Select(4, 0, Gen2.Bank.EPC, 0x20, tag.Epc.Length * 8, tag.Epc); MultiFilter selects = new MultiFilter(new Gen2.Select[] { resetFilter, epcFilter }); Gen2.ReadData operation = new Gen2.ReadData(bank, (uint)address, (byte)length); SimpleReadPlan config = new SimpleReadPlan(new int[] { tag.Antenna }, TagProtocol.GEN2, selects, operation, 1000); short[] values = null; try { reader.ParamSet("/reader/read/plan", config); for (int i = 0; i < attempts; i++) { if (values != null) { break; } TagReadData[] readResults = reader.Read(readTime); foreach (TagReadData readResult in readResults) { if (tag.EpcString.Equals(readResult.EpcString)) { byte[] dataBytes = readResult.Data; if (dataBytes.Length != 0) { values = ConvertByteArrayToShortArray(dataBytes); break; } } } } } catch (ReaderException e) { Console.WriteLine("Error: " + e.ToString()); Environment.Exit(-1); } if (values == null) { throw new SystemException("Tag not found"); } return(values); }
/// <summary> /// Read additional reserved memory for m5e variants /// </summary> /// <param name="bank"></param> /// <param name="startAddress"></param> /// <param name="filter"></param> /// <param name="data"></param> private void ReadAdditionalReservedMemDataM5eVariants(Gen2.Bank bank, uint startAddress, TagFilter filter, out ushort[] data) { data = null; int words = 1; TagOp op; while (true) { try { op = new Gen2.ReadData(bank, startAddress, Convert.ToByte(words)); data = (ushort[])objReader.ExecuteTagOp(op, filter); words++; } catch (Exception) { throw; } } }
/// <summary> /// Read tag memory for M5e Variants. If FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception /// or Non-specific reader error or General Tag Error or Tag data access failed exception /// is received. Memory reading is stopped and the already read data is returned /// </summary> /// <param name="bank">Gen2 memory bank</param> /// <param name="filter">Select filter</param> /// <param name="data">Read tag memory data is returned</param> private void ReadMemoryM5eVariants(Gen2.Bank bank, TagFilter filter, ref ushort[] data) { lock (new Object()) { List <ushort> dataTemp = new List <ushort>(); uint startaddress = 0; int words = 64; if (data != null) { // if the data variable already contains the data, then add that data // to data temp and change the start address to total data length dataTemp.AddRange(data); startaddress = (uint)data.Length; } TagOp op; bool isAllDataReceived = false; while (false == isAllDataReceived) { try { // Read tag memory op = new Gen2.ReadData(bank, startaddress, Convert.ToByte(words)); dataTemp.AddRange(((ushort[])objectReader.ExecuteTagOp(op, filter))); startaddress += 64; } catch (Exception exception) { if (exception is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception || (-1 != exception.Message.IndexOf("Non-specific reader error")) || (-1 != exception.Message.IndexOf("General Tag Error")) || (-1 != exception.Message.IndexOf("Tag data access failed"))) { data = dataTemp.ToArray(); ReadTagMemoryWordByWord(bank, filter, ref data); isAllDataReceived = true; } else { throw; } } } } }
static void Main(string[] args) { // Program setup if (1 > args.Length) { Usage(); } int[] antennaList = null; for (int nextarg = 1; nextarg < args.Length; nextarg++) { string arg = args[nextarg]; if (arg.Equals("--ant")) { if (null != antennaList) { Console.WriteLine("Duplicate argument: --ant specified more than once"); Usage(); } antennaList = ParseAntennaList(args, nextarg); nextarg++; } else { Console.WriteLine("Argument {0}:\"{1}\" is not recognized", nextarg, arg); Usage(); } } try { // Create Reader object, connecting to physical device. // Wrap reader in a "using" block to get automatic // reader shutdown (using IDisposable interface). using (Reader r = Reader.Create(args[0])) { //Uncomment this line to add default transport listener. //r.Transport += r.SimpleTransportListener; r.Connect(); if ((r is SerialReader) || (r is LlrpReader)) { if (Reader.Region.UNSPEC == (Reader.Region)r.ParamGet("/reader/region/id")) { Reader.Region[] supportedRegions = (Reader.Region[])r.ParamGet("/reader/region/supportedRegions"); if (supportedRegions.Length < 1) { throw new FAULT_INVALID_REGION_Exception(); } r.ParamSet("/reader/region/id", supportedRegions[0]); } string model = r.ParamGet("/reader/version/model").ToString(); if ((model.Equals("M6e Micro") || model.Equals("M6e Nano") || model.Equals("Sargas")) && antennaList == null) { Console.WriteLine("Module doesn't has antenna detection support please provide antenna list"); Usage(); } Gen2.Password pass = new Gen2.Password(0x0); r.ParamSet("/reader/gen2/accessPassword", pass); //Use first antenna for operation if (antennaList != null) { r.ParamSet("/reader/tagop/antenna", antennaList[0]); } // BlockWrite and read using ExecuteTagOp Gen2.BlockWrite blockwrite = new Gen2.BlockWrite(Gen2.Bank.USER, 0, new ushort[] { 0xFFF1, 0x1122 }); r.ExecuteTagOp(blockwrite, null); Gen2.ReadData read = new Gen2.ReadData(Gen2.Bank.USER, 0, 2); ushort[] readData = (ushort[])r.ExecuteTagOp(read, null); foreach (ushort word in readData) { Console.Write(" {0:X4}", word); } Console.WriteLine(); // BlockWrite and read using embedded read command SimpleReadPlan readplan; TagReadData[] tagreads; blockwrite = new Gen2.BlockWrite(Gen2.Bank.USER, 0, new ushort[] { 0x1234, 0x5678 }); readplan = new SimpleReadPlan(antennaList, TagProtocol.GEN2, //null, new TagData("1234567890ABCDEF"), blockwrite, 0); r.ParamSet("/reader/read/plan", readplan); r.Read(500); readplan = new SimpleReadPlan(antennaList, TagProtocol.GEN2, null, new Gen2.ReadData(Gen2.Bank.USER, 0, 2), 0); r.ParamSet("/reader/read/plan", readplan); tagreads = r.Read(500); foreach (TagReadData trd in tagreads) { foreach (byte b in trd.Data) { Console.Write(" {0:X2}", b); } Console.WriteLine(" " + trd); } } else { Console.WriteLine("Error: This codelet works only for Serial Readers and Llrp Readers"); } } } catch (ReaderException re) { Console.WriteLine("Error: " + re.Message); } catch (Exception ex) { Console.WriteLine("Error: " + ex.Message); } }
static void Main(string[] args) { // Program setup if (1 > args.Length) { Usage(); } int[] antennaList = null; for (int nextarg = 1; nextarg < args.Length; nextarg++) { string arg = args[nextarg]; if (arg.Equals("--ant")) { if (null != antennaList) { Console.WriteLine("Duplicate argument: --ant specified more than once"); Usage(); } antennaList = ParseAntennaList(args, nextarg); nextarg++; } else { Console.WriteLine("Argument {0}:\"{1}\" is not recognized", nextarg, arg); Usage(); } } // Create Reader object, connecting to physical device try { Reader r; TagReadData[] tagReads, filteredTagReads; TagFilter filter; r = Reader.Create(args[0]); //Uncomment this line to add default transport listener. //r.Transport += r.SimpleTransportListener; r.Connect(); if (Reader.Region.UNSPEC == (Reader.Region)r.ParamGet("/reader/region/id")) { Reader.Region[] supportedRegions = (Reader.Region[])r.ParamGet("/reader/region/supportedRegions"); if (supportedRegions.Length < 1) { throw new FAULT_INVALID_REGION_Exception(); } r.ParamSet("/reader/region/id", supportedRegions[0]); } string model = r.ParamGet("/reader/version/model").ToString(); if ((model.Equals("M6e Micro") || model.Equals("M6e Nano") || model.Equals("Sargas")) && antennaList == null) { Console.WriteLine("Module doesn't has antenna detection support please provide antenna list"); Usage(); } // In the current system, sequences of Gen2 operations require Session 0, // since each operation resingulates the tag. In other sessions, // the tag will still be "asleep" from the preceding singulation. Gen2.Session oldSession = (Gen2.Session)r.ParamGet("/reader/gen2/session"); Gen2.Session newSession = Gen2.Session.S0; Console.WriteLine("Changing to Session " + newSession + " (from Session " + oldSession + ")"); r.ParamSet("/reader/gen2/session", newSession); Console.WriteLine(); SimpleReadPlan srp = new SimpleReadPlan(antennaList, TagProtocol.GEN2); r.ParamSet("/reader/read/plan", srp); //To perform standalone operations if (antennaList != null) { r.ParamSet("/reader/tagop/antenna", antennaList[0]); } try { Console.WriteLine("Unfiltered Read:"); // Read the tags in the field tagReads = r.Read(500); foreach (TagReadData tr in tagReads) { Console.WriteLine(tr.ToString()); } Console.WriteLine(); if (0 == tagReads.Length) { Console.WriteLine("No tags found."); } else { // A TagData object may be used as a filter, for example to // perform a tag data operation on a particular tag. Console.WriteLine("Filtered Tagop:"); // Read kill password of tag found in previous operation filter = tagReads[0].Tag; Console.WriteLine("Read kill password of tag {0}", filter); Gen2.ReadData tagop = new Gen2.ReadData(Gen2.Bank.RESERVED, 0, 2); try { ushort[] data = (ushort[])r.ExecuteTagOp(tagop, filter); foreach (ushort word in data) { Console.Write("{0:X4}", word); } Console.WriteLine(); } catch (ReaderException ex) { Console.WriteLine("Can't read tag: {0}", ex.Message); } Console.WriteLine(); // Filter objects that apply to multiple tags are most useful in // narrowing the set of tags that will be read. This is // performed by setting a read plan that contains a filter. // A TagData with a short EPC will filter for tags whose EPC // starts with the same sequence. filter = new TagData(tagReads[0].Tag.EpcString.Substring(0, 4)); Console.WriteLine("EPCs that begin with {0}:", filter); r.ParamSet("/reader/read/plan", new SimpleReadPlan(antennaList, TagProtocol.GEN2, filter, 1000)); filteredTagReads = r.Read(500); foreach (TagReadData tr in filteredTagReads) { Console.WriteLine(tr.ToString()); } Console.WriteLine(); // A filter can also be an full Gen2 Select operation. For // example, this filter matches all Gen2 tags where bits 8-19 of // the TID are 0x003 (that is, tags manufactured by Alien // Technology). Console.WriteLine("Tags with Alien Technology TID"); filter = new Gen2.Select(false, Gen2.Bank.TID, 8, 12, new byte[] { 0, 0x30 }); r.ParamSet("/reader/read/plan", new SimpleReadPlan(antennaList, TagProtocol.GEN2, filter, 1000)); filteredTagReads = r.Read(500); foreach (TagReadData tr in filteredTagReads) { Console.WriteLine(tr.ToString()); } Console.WriteLine(); if (r is SerialReader) { // A filter can also be Gen2 Truncate Select operation. // Truncate indicates whether a Tag’s backscattered reply shall be truncated to those EPC bits that follow Mask. // For example, truncated select starting with PC word start address and length of 16 bits Console.WriteLine("GEN2 Select Truncate Operation"); filter = new Gen2.Select(false, Gen2.Bank.GEN2EPCTRUNCATE, 16, 40, new byte[] { 0x30, 0x00, 0xDE, 0xAD, 0xCA }); r.ParamSet("/reader/read/plan", new SimpleReadPlan(antennaList, TagProtocol.GEN2, filter, 1000)); filteredTagReads = r.Read(500); foreach (TagReadData tr in filteredTagReads) { Console.WriteLine(tr.ToString()); } Console.WriteLine(); // A filter can also perform Gen2 Tag Filtering. // Major advantage of this feature is to limit the EPC response to user specified length field and all others will be rejected by firmware. // invert, bitPointer, mask : Parameters will be ignored when TMR_GEN2_EPC_LENGTH_FILTER is used // maskBitLength : Specified EPC Length used for filtering // For example, Tag filtering will be applied on EPC with 128 bits length, rest of the tags will be ignored Console.WriteLine("GEN2 Tag Filter Based on EPC Length"); filter = new Gen2.Select(false, Gen2.Bank.GEN2EPCLENGTHFILTER, 16, 128, new byte[] { 0x30, 0x00 }); r.ParamSet("/reader/read/plan", new SimpleReadPlan(antennaList, TagProtocol.GEN2, filter, 1000)); filteredTagReads = r.Read(500); foreach (TagReadData tr in filteredTagReads) { Console.WriteLine(tr.ToString()); } Console.WriteLine(); } // Gen2 Select may also be inverted, to give all non-matching tags Console.WriteLine("Tags without Alien Technology TID"); filter = new Gen2.Select(true, Gen2.Bank.TID, 8, 12, new byte[] { 0, 0x30 }); r.ParamSet("/reader/read/plan", new SimpleReadPlan(antennaList, TagProtocol.GEN2, filter, 1000)); filteredTagReads = r.Read(500); foreach (TagReadData tr in filteredTagReads) { Console.WriteLine(tr.ToString()); } Console.WriteLine(); // Filters can also be used to match tags that have already been // read. This form can only match on the EPC, as that's the only // data from the tag's memory that is contained in a TagData // object. // Note that this filter has invert=true. This filter will match // tags whose bits do not match the selection mask. // Also note the offset - the EPC code starts at bit 32 of the // EPC memory bank, after the StoredCRC and StoredPC. filter = new Gen2.Select(true, Gen2.Bank.EPC, 32, 2, new byte[] { (byte)0xC0 }); Console.WriteLine("EPCs with first 2 bits equal to zero (post-filtered):"); foreach (TagReadData tr in tagReads) // unfiltered tag reads from the first example { if (filter.Matches(tr.Tag)) { Console.WriteLine(tr.ToString()); } } Console.WriteLine(); } } finally { // Restore original settings Console.WriteLine("Restoring Session " + oldSession); r.ParamSet("/reader/gen2/session", oldSession); } // Shut down reader r.Destroy(); } catch (ReaderException re) { Console.WriteLine("Error: " + re.Message); } catch (Exception ex) { Console.WriteLine("Error: " + ex.Message); } }
static void Main(string[] args) { // Program setup if (1 > args.Length) { Usage(); } int[] antennaList = null; for (int nextarg = 1; nextarg < args.Length; nextarg++) { string arg = args[nextarg]; if (arg.Equals("--ant")) { if (null != antennaList) { Console.WriteLine("Duplicate argument: --ant specified more than once"); Usage(); } antennaList = ParseAntennaList(args, nextarg); nextarg++; } else { Console.WriteLine("Argument {0}:\"{1}\" is not recognized", nextarg, arg); Usage(); } } try { // Create Reader object, connecting to physical device. // Wrap reader in a "using" block to get automatic // reader shutdown (using IDisposable interface). using (Reader r = Reader.Create(args[0])) { //Uncomment this line to add default transport listener. //r.Transport += r.SimpleTransportListener; r.Connect(); if (Reader.Region.UNSPEC == (Reader.Region)r.ParamGet("/reader/region/id")) { Reader.Region[] supportedRegions = (Reader.Region[])r.ParamGet("/reader/region/supportedRegions"); if (supportedRegions.Length < 1) { throw new FAULT_INVALID_REGION_Exception(); } r.ParamSet("/reader/region/id", supportedRegions[0]); } // Read Plan byte length; string model = r.ParamGet("/reader/version/model").ToString(); if ((model.Equals("M6e Micro") || model.Equals("M6e Nano") || model.Equals("Sargas")) && antennaList == null) { Console.WriteLine("Module doesn't has antenna detection support please provide antenna list"); Usage(); } if ("M6e".Equals(model) || "M6e PRC".Equals(model) || "M6e JIC".Equals(model) || "M6e Micro".Equals(model) || "Mercury6".Equals(model) || "Sargas".Equals(model) || "Astra-EX".Equals(model)) { // Specifying the readLength = 0 will return full TID for any tag read in case of M6e varients, M6 and Astra-EX reader. length = 0; } else { length = 2; } TagOp op = new Gen2.ReadData(Gen2.Bank.TID, 0, length); SimpleReadPlan plan = new SimpleReadPlan(antennaList, TagProtocol.GEN2, null, op, 1000); r.ParamSet("/reader/read/plan", plan); // Read tags TagReadData[] tagReads = r.Read(500); // Print tag reads foreach (TagReadData tr in tagReads) { Console.WriteLine(tr.ToString()); if (0 < tr.Data.Length) { Console.WriteLine(" Data:" + ByteFormat.ToHex(tr.Data, "", " ")); } } } } catch (ReaderException re) { Console.WriteLine("Error: " + re.Message); } catch (Exception ex) { Console.WriteLine("Error: " + ex.Message); } }
static void Main(string[] args) { // Program setup if (1 > args.Length) { Usage(); } for (int nextarg = 1; nextarg < args.Length; nextarg++) { string arg = args[nextarg]; if (arg.Equals("--ant")) { if (null != antennaList) { Console.WriteLine("Duplicate argument: --ant specified more than once"); Usage(); } antennaList = ParseAntennaList(args, nextarg); nextarg++; } else { Console.WriteLine("Argument {0}:\"{1}\" is not recognized", nextarg, arg); Usage(); } } try { // Create Reader object, connecting to physical device. // Wrap reader in a "using" block to get automatic // reader shutdown (using IDisposable interface). using (Reader r = Reader.Create(args[0])) { //Uncomment this line to add default transport listener. //r.Transport += r.SimpleTransportListener; r.Connect(); if (Reader.Region.UNSPEC == (Reader.Region)r.ParamGet("/reader/region/id")) { Reader.Region[] supportedRegions = (Reader.Region[])r.ParamGet("/reader/region/supportedRegions"); if (supportedRegions.Length < 1) { throw new FAULT_INVALID_REGION_Exception(); } r.ParamSet("/reader/region/id", supportedRegions[0]); } Gen2ReadAllMemoryBanks prgm = new Gen2ReadAllMemoryBanks(); prgm.reader = r; // Read Plan byte length; string model = (string)r.ParamGet("/reader/version/model"); if ((model.Equals("M6e Micro") || model.Equals("M6e Nano") || model.Equals("Sargas")) && antennaList == null) { Console.WriteLine("Module doesn't has antenna detection support please provide antenna list"); Usage(); } if ("M6e".Equals(model) || "M6e PRC".Equals(model) || "M6e JIC".Equals(model) || "M6e Micro".Equals(model) || "Mercury6".Equals(model) || "Sargas".Equals(model) || "Astra-EX".Equals(model)) { // Specifying the readLength = 0 will return full TID for any tag read in case of M6e varients, M6 and Astra-EX reader. length = 0; } else { length = 2; } prgm.PerformWriteOperation(); SimpleReadPlan srp = new SimpleReadPlan(antennaList, TagProtocol.GEN2, null, null, 1000); r.ParamSet("/reader/read/plan", srp); TagReadData[] tagReadsFilter = r.Read(500); if (tagReadsFilter.Length == 0) { Console.WriteLine("No tags found"); return; } TagFilter filter = new TagData(tagReadsFilter[0].EpcString); Console.WriteLine("Perform embedded and standalone tag operation - read only user memory without filter"); Console.WriteLine(); TagOp op = new Gen2.ReadData(Gen2.Bank.USER, 0, length); prgm.PerformReadAllMemOperation(null, op); Console.WriteLine(); Console.WriteLine("Perform embedded and standalone tag operation - read user memory, reserved memory, tid memory and epc memory without filter"); Console.WriteLine(); op = null; op = new Gen2.ReadData(Gen2.Bank.USER | Gen2.Bank.GEN2BANKUSERENABLED | Gen2.Bank.GEN2BANKRESERVEDENABLED | Gen2.Bank.GEN2BANKEPCENABLED | Gen2.Bank.GEN2BANKTIDENABLED, 0, length); prgm.PerformReadAllMemOperation(null, op); Console.WriteLine(); Console.WriteLine("Perform embedded and standalone tag operation - read only user memory with filter"); Console.WriteLine(); op = null; op = new Gen2.ReadData(Gen2.Bank.USER, 0, length); prgm.PerformReadAllMemOperation(filter, op); Console.WriteLine(); Console.WriteLine("Perform embedded and standalone tag operation - read user memory, reserved memory with filter"); Console.WriteLine(); op = null; op = new Gen2.ReadData(Gen2.Bank.USER | Gen2.Bank.GEN2BANKUSERENABLED | Gen2.Bank.GEN2BANKRESERVEDENABLED, 0, length); prgm.PerformReadAllMemOperation(filter, op); Console.WriteLine(); Console.WriteLine("Perform embedded and standalone tag operation - read user memory, reserved memory and tid memory with filter"); Console.WriteLine(); op = null; op = new Gen2.ReadData(Gen2.Bank.USER | Gen2.Bank.GEN2BANKUSERENABLED | Gen2.Bank.GEN2BANKRESERVEDENABLED | Gen2.Bank.GEN2BANKTIDENABLED, 0, length); prgm.PerformReadAllMemOperation(filter, op); Console.WriteLine(); Console.WriteLine("Perform embedded and standalone tag operation - read user memory, reserved memory, tid memory and epc memory with filter"); Console.WriteLine(); op = null; op = new Gen2.ReadData(Gen2.Bank.USER | Gen2.Bank.GEN2BANKUSERENABLED | Gen2.Bank.GEN2BANKRESERVEDENABLED | Gen2.Bank.GEN2BANKEPCENABLED | Gen2.Bank.GEN2BANKTIDENABLED, 0, length); prgm.PerformReadAllMemOperation(filter, op); Console.WriteLine(); } } catch (ReaderException re) { Console.WriteLine("Error: " + re.Message); } catch (Exception ex) { Console.WriteLine("Error: " + ex.Message); } }
static void Main(string[] args) { // Program setup if (1 > args.Length) { Usage(); } int[] antennaList = null; for (int nextarg = 1; nextarg < args.Length; nextarg++) { string arg = args[nextarg]; if (arg.Equals("--ant")) { if (null != antennaList) { Console.WriteLine("Duplicate argument: --ant specified more than once"); Usage(); } antennaList = ParseAntennaList(args, nextarg); nextarg++; } else { Console.WriteLine("Argument {0}:\"{1}\" is not recognized", nextarg, arg); Usage(); } } // Create Reader object, connecting to physical device try { Reader r; TagReadData[] tagReads, filteredTagReads; TagFilter filter; r = Reader.Create(args[0]); //Uncomment this line to add default transport listener. //r.Transport += r.SimpleTransportListener; r.Connect(); if (Reader.Region.UNSPEC == (Reader.Region)r.ParamGet("/reader/region/id")) { Reader.Region[] supportedRegions = (Reader.Region[])r.ParamGet("/reader/region/supportedRegions"); if (supportedRegions.Length < 1) { throw new FAULT_INVALID_REGION_Exception(); } r.ParamSet("/reader/region/id", supportedRegions[0]); } if (r.isAntDetectEnabled(antennaList)) { Console.WriteLine("Module doesn't has antenna detection support please provide antenna list"); Usage(); } // In the current system, sequences of Gen2 operations require Session 0, // since each operation resingulates the tag. In other sessions, // the tag will still be "asleep" from the preceding singulation. Gen2.Session oldSession = (Gen2.Session)r.ParamGet("/reader/gen2/session"); Gen2.Session newSession = Gen2.Session.S0; Console.WriteLine("Changing to Session " + newSession + " (from Session " + oldSession + ")"); r.ParamSet("/reader/gen2/session", newSession); Console.WriteLine(); SimpleReadPlan srp = new SimpleReadPlan(antennaList, TagProtocol.GEN2); r.ParamSet("/reader/read/plan", srp); //To perform standalone operations if (antennaList != null) { r.ParamSet("/reader/tagop/antenna", antennaList[0]); } try { Console.WriteLine("Unfiltered Read:"); // Read the tags in the field tagReads = r.Read(500); foreach (TagReadData tr in tagReads) { Console.WriteLine(tr.ToString()); } Console.WriteLine(); if (0 == tagReads.Length) { Console.WriteLine("No tags found."); } else { // A TagData object may be used as a filter, for example to // perform a tag data operation on a particular tag. Console.WriteLine("Filtered Tagop:"); // Read kill password of tag found in previous operation filter = tagReads[0].Tag; Console.WriteLine("Read kill password of tag {0}", filter); Gen2.ReadData tagop = new Gen2.ReadData(Gen2.Bank.RESERVED, 0, 2); try { ushort[] data = (ushort[])r.ExecuteTagOp(tagop, filter); foreach (ushort word in data) { Console.Write("{0:X4}", word); } Console.WriteLine(); } catch (ReaderException ex) { Console.WriteLine("Can't read tag: {0}", ex.Message); } Console.WriteLine(); // Filter objects that apply to multiple tags are most useful in // narrowing the set of tags that will be read. This is // performed by setting a read plan that contains a filter. // A TagData with a short EPC will filter for tags whose EPC // starts with the same sequence. filter = new TagData(tagReads[0].Tag.EpcString.Substring(0, 4)); Console.WriteLine("EPCs that begin with {0}:", filter); r.ParamSet("/reader/read/plan", new SimpleReadPlan(antennaList, TagProtocol.GEN2, filter, 1000)); filteredTagReads = r.Read(500); foreach (TagReadData tr in filteredTagReads) { Console.WriteLine(tr.ToString()); } Console.WriteLine(); // A filter can also be an full Gen2 Select operation. For // example, this filter matches all Gen2 tags where bits 8-19 of // the TID are 0x003 (that is, tags manufactured by Alien // Technology). // In case of Network readers, ensure that bitLength is a multiple of 8. Console.WriteLine("Tags with Alien Technology TID"); filter = new Gen2.Select(false, Gen2.Bank.TID, 8, 12, new byte[] { 0, 0x30 }); r.ParamSet("/reader/read/plan", new SimpleReadPlan(antennaList, TagProtocol.GEN2, filter, 1000)); filteredTagReads = r.Read(500); foreach (TagReadData tr in filteredTagReads) { Console.WriteLine(tr.ToString()); } Console.WriteLine(); if (r is SerialReader) { // A filter can also be Gen2 Truncate Select operation. // Truncate indicates whether a Tag’s backscattered reply shall be truncated to those EPC bits that follow Mask. // For example, truncated select starting with PC word start address and length of 16 bits // In case of Network readers, ensure that bitLength is a multiple of 8. Console.WriteLine("GEN2 Select Truncate Operation"); filter = new Gen2.Select(false, Gen2.Bank.GEN2EPCTRUNCATE, 16, 40, new byte[] { 0x30, 0x00, 0xDE, 0xAD, 0xCA }); r.ParamSet("/reader/read/plan", new SimpleReadPlan(antennaList, TagProtocol.GEN2, filter, 1000)); filteredTagReads = r.Read(500); foreach (TagReadData tr in filteredTagReads) { Console.WriteLine(tr.ToString()); } Console.WriteLine(); // A filter can also perform Gen2 Tag Filtering. // Major advantage of this feature is to limit the EPC response to user specified length field and all others will be rejected by firmware. // invert, bitPointer, mask : Parameters will be ignored when TMR_GEN2_EPC_LENGTH_FILTER is used // maskBitLength : Specified EPC Length used for filtering // For example, Tag filtering will be applied on EPC with 128 bits length, rest of the tags will be ignored // In case of Network readers, ensure that bitLength is a multiple of 8. Console.WriteLine("GEN2 Tag Filter Based on EPC Length"); filter = new Gen2.Select(false, Gen2.Bank.GEN2EPCLENGTHFILTER, 16, 128, new byte[] { 0x30, 0x00 }); r.ParamSet("/reader/read/plan", new SimpleReadPlan(antennaList, TagProtocol.GEN2, filter, 1000)); filteredTagReads = r.Read(500); foreach (TagReadData tr in filteredTagReads) { Console.WriteLine(tr.ToString()); } Console.WriteLine(); } // Gen2 Select may also be inverted, to give all non-matching tags // In case of Network readers, ensure that bitLength is a multiple of 8. Console.WriteLine("Tags without Alien Technology TID"); filter = new Gen2.Select(true, Gen2.Bank.TID, 8, 12, new byte[] { 0, 0x30 }); r.ParamSet("/reader/read/plan", new SimpleReadPlan(antennaList, TagProtocol.GEN2, filter, 1000)); filteredTagReads = r.Read(500); foreach (TagReadData tr in filteredTagReads) { Console.WriteLine(tr.ToString()); } Console.WriteLine(); // Filters can also be used to match tags that have already been // read. This form can only match on the EPC, as that's the only // data from the tag's memory that is contained in a TagData // object. // Note that this filter has invert=true. This filter will match // tags whose bits do not match the selection mask. // Also note the offset - the EPC code starts at bit 32 of the // EPC memory bank, after the StoredCRC and StoredPC. // In case of Network readers, ensure that bitLength is a multiple of 8. filter = new Gen2.Select(true, Gen2.Bank.EPC, 32, 2, new byte[] { (byte)0xC0 }); Console.WriteLine("EPCs with first 2 bits equal to zero (post-filtered):"); foreach (TagReadData tr in tagReads) // unfiltered tag reads from the first example { if (filter.Matches(tr.Tag)) { Console.WriteLine(tr.ToString()); } } Console.WriteLine(); /** * Multi filter creation and initialization. This filter will match those tags whose bits matches the * selection mask of both tidFilter(tags manufactured by Alien Technology) and epcFilter(epc of first * tag read from tagReads[0]). Target and action are the two new parameters of Gen2.Select class whose * default values could be "Gen2.Select.Target.Select" and "Gen2.Select.Action.ON_N_OFF" respectively * if not provided by the user. * * Gen2 Select Action indicates which Select action to take * (See Gen2 spec /Select commands / Tag response to Action parameter) * |-----------------------------------------------------------------------------| * | Action | Tag Matching | Tag Not-Matching | * |----------|--------------------------------|---------------------------------| * | 0x00 | Assert SL or Inventoried->A | Deassert SL or Inventoried->B | * | 0x01 | Assert SL or Inventoried->A | Do nothing | * | 0x02 | Do nothing | Deassert SL or Inventoried->B | * | 0x03 | Negate SL or (A->B,B->A) | Do nothing | * | 0x04 | Deassert SL or Inventoried->B | Assert SL or Inventoried->A | * | 0x05 | Deassert SL or Inventoried->B | Do nothing | * | 0x06 | Do nothing | Assert SL or Inventoried->A | * | 0x07 | Do nothing | Negate SL or (A->B,B->A) | * * * To improve readability and ease typing, these names abbreviate the official terminology of the Gen2 spec. * <A>_N_<B>: The "_N_" stands for "Non-Matching". * The <A> clause before the _N_ describes what happens to Matching tags. * The <B> clause after the _N_ describes what happens to Non-Matching tags. * (Alternately, you can pronounce "_N_" as "and", or "&"; i.e., * the pair of Matching / Non-Matching actions is known as "<A> and <B>".) * * ON: assert SL or inventoried -> A * OFF: deassert SL or inventoried -> B * NEG: negate SL or (A->B, B->A) * NOP: do nothing * * The enum is simply a transliteration of the Gen2 spec's table: "Tag response to Action parameter" */ // create and initialize tidFilter // In case of Network readers, ensure that bitLength is a multiple of 8. Gen2.Select tidFilter = new Gen2.Select(false, Gen2.Bank.TID, 32, 16, new byte[] { (byte)0x01, (byte)0x2E }); tidFilter.target = Gen2.Select.Target.Select; tidFilter.action = Gen2.Select.Action.ON_N_OFF; // create and initialize epcFilter // In case of Network readers, ensure that bitLength is a multiple of 8. Gen2.Select epcFilter = new Gen2.Select(false, Gen2.Bank.EPC, 32, 16, new byte[] { (byte)0x11, (byte)0x22 }); epcFilter.target = Gen2.Select.Target.Select; epcFilter.action = Gen2.Select.Action.ON_N_OFF; // Initialize multifilter with tagFilter array containing list of filters // In case of Network readers, ensure that bitLength is a multiple of 8. MultiFilter multiFilter = new MultiFilter(new TagFilter[] { tidFilter, epcFilter }); r.ParamSet("/reader/read/plan", new SimpleReadPlan(antennaList, TagProtocol.GEN2, multiFilter, 1000)); Console.WriteLine("Reading tags which matches multi filter criteria \n", filter.ToString()); filteredTagReads = r.Read(500); foreach (TagReadData tr in filteredTagReads) { Console.WriteLine(tr.ToString()); } Console.WriteLine(); } } finally { // Restore original settings Console.WriteLine("Restoring Session " + oldSession); r.ParamSet("/reader/gen2/session", oldSession); } // Shut down reader r.Destroy(); } catch (ReaderException re) { Console.WriteLine("Error: " + re.Message); } catch (Exception ex) { Console.WriteLine("Error: " + ex.Message); } }
static void Main(string[] args) { // Program setup if (args.Length != 1) { Console.WriteLine("Please provide reader URL, such as:\n" + "tmr:///com4\n" + "tmr://my-reader.example.com\n"); Environment.Exit(1); } // Create Reader object, connecting to physical device try { Reader r; TagReadData[] tagReads, filteredTagReads; TagFilter filter; r = Reader.Create(args[0]); //Uncomment this line to add default transport listener. //r.Transport += r.SimpleTransportListener; r.Connect(); if (Reader.Region.UNSPEC == (Reader.Region)r.ParamGet("/reader/region/id")) { Reader.Region[] supportedRegions = (Reader.Region[])r.ParamGet("/reader/region/supportedRegions"); if (supportedRegions.Length < 1) { throw new FAULT_INVALID_REGION_Exception(); } else { r.ParamSet("/reader/region/id", supportedRegions[0]); } } // In the current system, sequences of Gen2 operations require Session 0, // since each operation resingulates the tag. In other sessions, // the tag will still be "asleep" from the preceding singulation. Gen2.Session oldSession = (Gen2.Session)r.ParamGet("/reader/gen2/session"); Gen2.Session newSession = Gen2.Session.S0; Console.WriteLine("Changing to Session " + newSession + " (from Session " + oldSession + ")"); r.ParamSet("/reader/gen2/session", newSession); Console.WriteLine(); try { Console.WriteLine("Unfiltered Read:"); // Read the tags in the field tagReads = r.Read(500); foreach (TagReadData tr in tagReads) { Console.WriteLine(tr.ToString()); } Console.WriteLine(); if (0 == tagReads.Length) { Console.WriteLine("No tags found."); } else { // A TagData object may be used as a filter, for example to // perform a tag data operation on a particular tag. Console.WriteLine("Filtered Tagop:"); // Read kill password of tag found in previous operation filter = tagReads[0].Tag; Console.WriteLine("Read kill password of tag {0}", filter); Gen2.ReadData tagop = new Gen2.ReadData(Gen2.Bank.RESERVED, 0, 2); try { ushort[] data = (ushort[])r.ExecuteTagOp(tagop, filter); foreach (ushort word in data) { Console.Write("{0:X4}", word); } Console.WriteLine(); } catch (ReaderException ex) { Console.WriteLine("Can't read tag: {0}", ex.Message); } Console.WriteLine(); // Filter objects that apply to multiple tags are most useful in // narrowing the set of tags that will be read. This is // performed by setting a read plan that contains a filter. // A TagData with a short EPC will filter for tags whose EPC // starts with the same sequence. filter = new TagData(tagReads[0].Tag.EpcString.Substring(0, 4)); Console.WriteLine("EPCs that begin with {0}:", filter); r.ParamSet("/reader/read/plan", new SimpleReadPlan(null, TagProtocol.GEN2, filter, 1000)); filteredTagReads = r.Read(500); foreach (TagReadData tr in filteredTagReads) { Console.WriteLine(tr.ToString()); } Console.WriteLine(); // A filter can also be an full Gen2 Select operation. For // example, this filter matches all Gen2 tags where bits 8-19 of // the TID are 0x003 (that is, tags manufactured by Alien // Technology). Console.WriteLine("Tags with Alien Technology TID"); filter = new Gen2.Select(false, Gen2.Bank.TID, 8, 12, new byte[] { 0, 0x30 }); r.ParamSet("/reader/read/plan", new SimpleReadPlan(null, TagProtocol.GEN2, filter, 1000)); filteredTagReads = r.Read(500); foreach (TagReadData tr in filteredTagReads) { Console.WriteLine(tr.ToString()); } Console.WriteLine(); // Gen2 Select may also be inverted, to give all non-matching tags Console.WriteLine("Tags without Alien Technology TID"); filter = new Gen2.Select(true, Gen2.Bank.TID, 8, 12, new byte[] { 0, 0x30 }); r.ParamSet("/reader/read/plan", new SimpleReadPlan(null, TagProtocol.GEN2, filter, 1000)); filteredTagReads = r.Read(500); foreach (TagReadData tr in filteredTagReads) { Console.WriteLine(tr.ToString()); } Console.WriteLine(); // Filters can also be used to match tags that have already been // read. This form can only match on the EPC, as that's the only // data from the tag's memory that is contained in a TagData // object. // Note that this filter has invert=true. This filter will match // tags whose bits do not match the selection mask. // Also note the offset - the EPC code starts at bit 32 of the // EPC memory bank, after the StoredCRC and StoredPC. filter = new Gen2.Select(true, Gen2.Bank.EPC, 32, 2, new byte[] { (byte)0xC0 }); Console.WriteLine("EPCs with first 2 bits equal to zero (post-filtered):"); foreach (TagReadData tr in tagReads) // unfiltered tag reads from the first example { if (filter.Matches(tr.Tag)) { Console.WriteLine(tr.ToString()); } } Console.WriteLine(); } } finally { // Restore original settings Console.WriteLine("Restoring Session " + oldSession); r.ParamSet("/reader/gen2/session", oldSession); } // Shut down reader r.Destroy(); } catch (ReaderException re) { Console.WriteLine("Error: " + re.ToString()); } catch (Exception ex) { Console.WriteLine("Error: " + ex.Message); } }
static void Main(string[] args) { // Program setup if (1 > args.Length) { Usage(); } TagFilter filter = null; for (int nextarg = 1; nextarg < args.Length; nextarg++) { string arg = args[nextarg]; if (arg.Equals("--ant")) { if (null != antennaList) { Console.WriteLine("Duplicate argument: --ant specified more than once"); Usage(); } antennaList = ParseAntennaList(args, nextarg); nextarg++; } else { Console.WriteLine("Argument {0}:\"{1}\" is not recognized", nextarg, arg); Usage(); } } try { // Create Reader object, connecting to physical device. // Wrap reader in a "using" block to get automatic // reader shutdown (using IDisposable interface). using (r = Reader.Create(args[0])) { //Uncomment this line to add default transport listener. //r.Transport += r.SimpleTransportListener; r.Connect(); if (Reader.Region.UNSPEC == (Reader.Region)r.ParamGet("/reader/region/id")) { Reader.Region[] supportedRegions = (Reader.Region[])r.ParamGet("/reader/region/supportedRegions"); if (supportedRegions.Length < 1) { throw new FAULT_INVALID_REGION_Exception(); } r.ParamSet("/reader/region/id", supportedRegions[0]); } if (r.isAntDetectEnabled(antennaList)) { Console.WriteLine("Module doesn't has antenna detection support please provide antenna list"); Usage(); } //Use first antenna for operation if (antennaList != null) { r.ParamSet("/reader/tagop/antenna", antennaList[0]); } // This select filter matches all Gen2 tags where bits 32-48 of the EPC are 0x0123 #if ENABLE_FILTER filter = new Gen2.Select(false, Gen2.Bank.EPC, 32, 16, new byte[] { 0x01, 0x23 }); #endif //Gen2.TagData epc = new Gen2.TagData(new byte[] { // 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, // 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, //}); //Gen2.WriteTag tagop = new Gen2.WriteTag(epc); //r.ExecuteTagOp(tagop, null); // Reads data from a tag memory bank after writing data to the requested memory bank without powering down of tag #if ENABLE_READ_AFTER_WRITE { //create a tagopList with write tagop followed by read tagop TagOpList tagopList = new TagOpList(); byte wordCount; ushort[] readData; //Write one word of data to USER memory and read back 8 words from EPC memory using WriteData and ReadData { ushort[] writeData = { 0x9999 }; wordCount = 8; Gen2.WriteData wData = new Gen2.WriteData(Gen2.Bank.USER, 2, writeData); Gen2.ReadData rData = new Gen2.ReadData(Gen2.Bank.EPC, 0, wordCount); //Gen2.WriteTag wTag = new Gen2.WriteTag(epc); // assemble tagops into list tagopList.list.Add(wData); tagopList.list.Add(rData); Console.WriteLine("###################Embedded Read after write######################"); // uncomment the following for embedded read after write. embeddedReadAfterWrite(null, tagopList); // call executeTagOp with list of tagops //readData = (ushort[])r.ExecuteTagOp(tagopList, null); //Console.WriteLine("ReadData: "); //foreach (ushort word in readData) //{ // Console.Write(" {0:X4}", word); //} //Console.WriteLine("\n"); } //clearing the list for next operation tagopList.list.Clear(); //Write 12 bytes(6 words) of EPC and read back 8 words from EPC memory using WriteTag and ReadData { Gen2.TagData epc1 = new Gen2.TagData(new byte[] { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, }); wordCount = 8; Gen2.WriteTag wtag = new Gen2.WriteTag(epc1); Gen2.ReadData rData = new Gen2.ReadData(Gen2.Bank.EPC, 0, wordCount); // assemble tagops into list tagopList.list.Add(wtag); tagopList.list.Add(rData); // call executeTagOp with list of tagops //readData = (ushort[])r.ExecuteTagOp(tagopList, null); //Console.WriteLine("ReadData: "); //foreach (ushort word in readData) //{ // Console.Write(" {0:X4}", word); //} //Console.WriteLine("\n"); } } #endif } } catch (ReaderException re) { Console.WriteLine("Error: " + re.Message); } catch (Exception ex) { Console.WriteLine("Error: " + ex.Message); } }
/// <summary> /// Read tag memory when tag has more then 64 words or 128 bytes. And module doesn't supports zero address and zero length. /// Reads the tag memory with 0 address and length of words as 64. If memory overrun received. Initiates reading of tag /// word by word with start address as length of already read data and length of words to read as 0. Returns the data read from /// tag memory. /// </summary> /// <param name="bank">Gen2 memory bank</param> /// <param name="filter">filter</param> /// <param name="data">Data read from tag memory</param> private void ReadLargeTagMemoryWithoutZeroLengthSupport(Gen2.Bank bank, TagFilter filter, ref ushort[] data) { lock (new Object()) { data = null; // Data from tag memory List <ushort> dataTemp = new List <ushort>(); // Number of words to read int words = 64; // Start address uint startaddress = 0; TagOp op; bool isAllDataReceived = false; // Read till all the data from the tag memory is read while (false == isAllDataReceived) { try { op = new Gen2.ReadData(bank, startaddress, Convert.ToByte(words)); dataTemp.AddRange(((ushort[])objectReader.ExecuteTagOp(op, filter))); // Increment the start address to 64 and keep length of words to read as 64 for // all the iterations startaddress += 64; } catch (Exception ex) { try { if (ex is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception || (-1 != ex.Message.IndexOf("Non-specific reader error")) || (-1 != ex.Message.IndexOf("General Tag Error")) || (-1 != ex.Message.IndexOf("Tag data access failed"))) { // If the memory to read requested is more then the available memory in the tag, then initiate // reading the tag memory word by word with start address as length of already read data if exists // and length of words to read is 1 if (dataTemp.Count > 0) { // If some data is already read then include this data also so that // reading of memory doesn't continue from zero and the list should // not contain same data twice data = dataTemp.ToArray(); } ReadTagMemoryWordByWord(bank, filter, ref data); // Come out of main while loop. And read the already read data isAllDataReceived = true; } else { throw; } } catch (Exception exception) { // If more then once the below exceptions are received then come out of the loop. if (exception is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception || (-1 != exception.Message.IndexOf("Non-specific reader error")) || (-1 != exception.Message.IndexOf("General Tag Error")) || (-1 != exception.Message.IndexOf("Tag data access failed"))) { if (dataTemp.Count > 0) { // Just skip the exception and move on. So as not to lose the already read data. isAllDataReceived = false; } else { // throw the exception if the data received is null for the first iteration itself throw; } } else { throw; } } } } } }
static void Main(string[] args) { // Program setup if (1 != args.Length) { Console.WriteLine(String.Join("\r\n", new string[] { "Please provide reader URL, such as:", "tmr:///com4", "tmr://my-reader.example.com", })); Environment.Exit(1); } try { // Create Reader object, connecting to physical device. // Wrap reader in a "using" block to get automatic // reader shutdown (using IDisposable interface). using (Reader r = Reader.Create(args[0])) { //Uncomment this line to add default transport listener. //r.Transport += r.SimpleTransportListener; r.Connect(); if (Reader.Region.UNSPEC == (Reader.Region)r.ParamGet("/reader/region/id")) { Reader.Region[] supportedRegions = (Reader.Region[])r.ParamGet("/reader/region/supportedRegions"); if (supportedRegions.Length < 1) { throw new FAULT_INVALID_REGION_Exception(); } else { r.ParamSet("/reader/region/id", supportedRegions[0]); } } TagReadData[] tagReads; // Read Plan byte length; string model = (string)r.ParamGet("/reader/version/model"); if ("M6e".Equals(model) || "M6e PRC".Equals(model) || "M6e Micro".Equals(model) || "Mercury6".Equals(model) || "Astra-EX".Equals(model)) { // Specifying the readLength = 0 will return full TID for any tag read in case of M6e varients, M6 and Astra-EX reader. length = 0; } else { length = 2; } TagOp op = new Gen2.ReadData(Gen2.Bank.TID, 0, length); SimpleReadPlan plan = new SimpleReadPlan(null, TagProtocol.GEN2, null, op, 1000); r.ParamSet("/reader/read/plan", plan); // Read tags tagReads = r.Read(500); // Print tag reads foreach (TagReadData tr in tagReads) { Console.WriteLine(tr.ToString()); if (0 < tr.Data.Length) { Console.WriteLine(" Data:" + ByteFormat.ToHex(tr.Data, "", " ")); } } } } catch (ReaderException re) { Console.WriteLine("Error: " + re.Message); } catch (Exception ex) { Console.WriteLine("Error: " + ex.Message); } }
/// <summary> /// Populate keys of the tag /// </summary> private void PopulateAuthenticateData() { try { Mouse.SetCursor(Cursors.Wait); ResetUntraceableFields(); if ((bool)rbFirstTagAuthenticateTb.IsChecked) { antenna = GetSelectedAntennaList()[0]; } objReader.ParamSet("/reader/tagop/antenna", antenna); if ((bool)rbSelectedTagAuthenticateTb.IsChecked) { if (lblSelectFilter.Content.ToString().Contains("EPC ID")) { searchSelect = new TagData(currentEPC); } else { int dataLength = 0; byte[] SearchSelectData = ByteFormat.FromHex(txtData.Text); if (null != SearchSelectData) { dataLength = SearchSelectData.Length; } searchSelect = new Gen2.Select(false, selectMemBank, Convert.ToUInt16(startAddress * 16), Convert.ToUInt16(dataLength * 8), SearchSelectData); } } else { searchSelect = new TagData(currentEPC); } TagOp op; try { ushort[] Key0 = null; string CurrentKeyZero = string.Empty; op = new Gen2.ReadData(Gen2.Bank.USER, 0xC0, 8); Key0 = (ushort[])objReader.ExecuteTagOp(op, searchSelect); if (null != Key0) { CurrentKeyZero = ByteFormat.ToHex(ByteConv.ConvertFromUshortArray(Key0), "", " "); } crntKey0Value.Content = CurrentKeyZero; txtbxKeyZero.IsEnabled = true; txtbxKeyZero.Text = CurrentKeyZero; } catch (Exception ex) { if (ex is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception) { crntKey0Value.Content = "Key0 is inserted and activated"; txtbxKeyZero.IsEnabled = false; } } try { ushort[] Key1 = null; string CurrentKeyOne = string.Empty; op = new Gen2.ReadData(Gen2.Bank.USER, 0xD0, 8); Key1 = (ushort[])objReader.ExecuteTagOp(op, searchSelect); if (null != Key1) { CurrentKeyOne = ByteFormat.ToHex(ByteConv.ConvertFromUshortArray(Key1), "", " "); } crntKey1Value.Content = CurrentKeyOne; txtbxKeyOne.IsEnabled = true; txtbxKeyOne.Text = CurrentKeyOne; } catch (Exception ex) { if (ex is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception) { crntKey1Value.Content = "Key1 is inserted and activated"; txtbxKeyOne.IsEnabled = false; } } } catch (Exception ex) { MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error); } finally { Mouse.SetCursor(Cursors.Arrow); } }
/// <summary> /// Populate access password of the tag /// </summary> private void PopulateUntraceableData() { try { Mouse.SetCursor(Cursors.Wait); spUntraceableFields.IsEnabled = true; ResetUntraceableActionCheckBoxes(); if ((bool)rbFirstTagUntraceableTb.IsChecked) { antenna = GetSelectedAntennaList()[0]; } objReader.ParamSet("/reader/tagop/antenna", antenna); if ((bool)rbSelectedTagUntraceableTb.IsChecked) { if (lblSelectFilter.Content.ToString().Contains("EPC ID")) { searchSelect = new TagData(currentEPC); } else { int dataLength = 0; byte[] SearchSelectData = ByteFormat.FromHex(txtData.Text); if (null != SearchSelectData) { dataLength = SearchSelectData.Length; } searchSelect = new Gen2.Select(false, selectMemBank, Convert.ToUInt16(accessPwddStartAddress * 16), Convert.ToUInt16(dataLength * 8), SearchSelectData); } } else { searchSelect = new TagData(currentEPC); } //Read Reserved memory bank data TagOp op; ushort[] reservedData = null; txtbxAccesspaasword.Text = ""; try { string reservedBankData = string.Empty; //Read access password op = new Gen2.ReadData(Gen2.Bank.RESERVED, 2, 2); reservedData = (ushort[])objReader.ExecuteTagOp(op, searchSelect); if (null != reservedData) { reservedBankData = ByteFormat.ToHex(ByteConv.ConvertFromUshortArray(reservedData), "", " "); } txtbxAccesspaasword.Text = reservedBankData.Trim(' '); } catch (Exception ex) { MessageBox.Show(ex.Message); } } catch (Exception ex) { MessageBox.Show(ex.Message); } }
public void defaultSettings() { String x; String y; String z; int[] antennaList = null; TagFilter filter0; filter0 = new TagData("AA"); Reader r = Reader.Create("tmr:///com25"); r.Connect(); TagOp op = new Gen2.ReadData(Gen2.Bank.USER, 0x104, 3); SimpleReadPlan plan = new SimpleReadPlan(antennaList, TagProtocol.GEN2, filter0, op, true, 150); r.ParamSet("/reader/gen2/blf", Gen2.LinkFrequency.LINK640KHZ); // r.ParamSet("/reader/gen2/target", Gen2.Target.AB); // MultiReadPlan testMultiReadPlan = new MultiReadPlan(readPlans); // r.ParamSet("/reader/read/plan", testMultiReadPlan); //r.ParamSet("/reader/read/asyncOnTime", 25000); //r.ParamSet("/reader/read/asyncOffTime", 200); r.ParamSet("/reader/region/id", Reader.Region.EU3); Gen2.BAPParameters bap = (Gen2.BAPParameters)r.ParamGet("/reader/gen2/bap"); bap.FREQUENCYHOPOFFTIME = 20; bap.POWERUPDELAY = 3; r.ParamSet("/reader/gen2/bap", bap); // r.ParamSet("/reader/baudRate", 921600); r.ParamSet("/reader/read/plan", plan); r.TagRead += delegate(Object sender, TagReadDataEventArgs e) { //Debug.Print("I am here"); String userMem = ByteFormat.ToHex(e.TagReadData.Data).ToString(); // convert the input into a hex string // Debug.Print(userMem); String abc = e.TagReadData.EpcString; Debug.Print(abc); userMem.Trim(); int length = 4; int substringposition = 2; if (abc == "AAA2") { while (substringposition < 3) // split the string into small chunks per value and convert to INT { Debug.Print("I am in this loop"); x = userMem.Substring(substringposition, length); xInt = Convert.ToInt32(x, 16); substringposition = substringposition + length; bufferX = xInt.ToString(); Debug.Print(bufferX); y = userMem.Substring(substringposition, length); yInt = Convert.ToInt32(y, 16); substringposition = substringposition + length; bufferY = yInt.ToString(); z = userMem.Substring(substringposition, length); zInt = Convert.ToInt32(z, 16); substringposition = substringposition + length; bufferZ = zInt.ToString(); //updateText(xInt, yInt, zInt); Debug.Print(x + " " + y + " " + z); // updateProgressBars(xInt, yInt, zInt); } } Action action = delegate() { updateText(); updateProgressBars(); }; Dispatcher.BeginInvoke(DispatcherPriority.Normal, action); }; r.StartReading(); // Console.WriteLine("\r\n<Do other work here>\r\n"); // Thread.Sleep(50000000); // r.Dispose(); }
static void Main(string[] args) { bool enableFilter = false; TagFilter filter = null; // Program setup if (1 > args.Length) { Usage(); } for (int nextarg = 1; nextarg < args.Length; nextarg++) { string arg = args[nextarg]; if (arg.Equals("--ant")) { if (null != antennaList) { Console.WriteLine("Duplicate argument: --ant specified more than once"); Usage(); } antennaList = ParseAntennaList(args, nextarg); nextarg++; } else { Console.WriteLine("Argument {0}:\"{1}\" is not recognized", nextarg, arg); Usage(); } } try { // Create Reader object, connecting to physical device. // Wrap reader in a "using" block to get automatic // reader shutdown (using IDisposable interface). using (r = Reader.Create(args[0])) { //Uncomment this line to add default transport listener. //r.Transport += r.SimpleTransportListener; r.Connect(); if (Reader.Region.UNSPEC == (Reader.Region)r.ParamGet("/reader/region/id")) { Reader.Region[] supportedRegions = (Reader.Region[])r.ParamGet("/reader/region/supportedRegions"); if (supportedRegions.Length < 1) { throw new FAULT_INVALID_REGION_Exception(); } r.ParamSet("/reader/region/id", supportedRegions[0]); } if (r.isAntDetectEnabled(antennaList)) { Console.WriteLine("Module doesn't has antenna detection support please provide antenna list"); Usage(); } //Use first antenna for operation if (antennaList != null) { r.ParamSet("/reader/tagop/antenna", antennaList[0]); } if (enableFilter) { // If select filter is to be enabled byte[] mask = new byte[] { (byte)0x30, (byte)0x28, (byte)0x35, (byte)0x4D, (byte)0x82, (byte)0x02, (byte)0x02, (byte)0x80, (byte)0x00, (byte)0x01, (byte)0x04, (byte)0xAC }; filter = new Gen2.Select(false, Gen2.Bank.EPC, 32, 96, mask); } //Get Sensor Data of EM4325 tag bool sendUid = true; bool sendNewSample = true; Gen2.EMMicro.EM4325.GetSensorData getSensorOp = new Gen2.EMMicro.EM4325.GetSensorData(sendUid, sendNewSample); try { Console.WriteLine("****Executing standalone tag operation of Get sensor Data command of EM4325 tag****"); byte[] response = (byte[])r.ExecuteTagOp(getSensorOp, filter); // Parse the response of GetSensorData Console.WriteLine("****Get sensor Data command is success****"); GetSensorDataResponse rData = new GetSensorDataResponse(response); Console.WriteLine(rData.ToString()); } catch (Exception ex) { Console.WriteLine("Exception from executing get Sensor Data command: " + ex.Message); } //Embedded tag operation of Get sensor data try { Console.WriteLine("****Executing embedded tag operation of Get sensor Data command of EM4325 tag****"); embeddedRead(TagProtocol.GEN2, filter, getSensorOp); } catch (Exception ex) { Console.WriteLine("Exception from embedded get sensor data: " + ex.Message); } //Reset alarms command // Read back the temperature control word at 0xEC address to verify reset enable alarm bit is set before executing reset alarm tag op. Console.WriteLine("Reading Temperature control word 1 before resetting alarms to ensure reset enable bit is set to 1"); byte[] filterMask = new byte[] { (byte)0x04, (byte)0xc2 }; Gen2.Select select = new Gen2.Select(false, Gen2.Bank.EPC, 0x70, 16, filterMask); Gen2.ReadData rdata = new Gen2.ReadData(Gen2.Bank.USER, 0xEC, (byte)0x1); ushort[] resp = (ushort[])r.ExecuteTagOp(rdata, select); Console.WriteLine("Temp control word 1: "); foreach (ushort i in resp) { Console.Write(" {0:X4}", i); } Console.WriteLine("\n"); // If temperature control word is not 0x4000, write the data if (resp[0] != 0x4000) { ushort[] writeData = new ushort[] { 0x4000 }; Gen2.WriteData wData = new Gen2.WriteData(Gen2.Bank.USER, 0xEC, writeData); r.ExecuteTagOp(wData, select); } Gen2.EMMicro.EM4325.ResetAlarms resetAlarmsOp = new Gen2.EMMicro.EM4325.ResetAlarms(); try { Console.WriteLine("****Executing standalone tag operation of Reset alarms command of EM4325 tag****"); r.ExecuteTagOp(resetAlarmsOp, filter); Console.WriteLine("****Reset Alarms command is success****"); } catch (Exception ex) { Console.WriteLine("Exception from executing reset alarms : " + ex.Message); } //Embedded tag operation of reset alarms command try { Console.WriteLine("****Executing embedded tag operation of reset alarms command of EM4325 tag****"); embeddedRead(TagProtocol.GEN2, filter, resetAlarmsOp); } catch (Exception ex) { Console.WriteLine("Exception from embedded reset alarms command: " + ex.Message); } } } catch (ReaderException re) { Console.WriteLine("Error: " + re.Message); Console.Out.Flush(); } catch (Exception ex) { Console.WriteLine("Error: " + ex.Message); } }
private void ReadReservedMemData(Gen2.Bank bank, TagFilter filter) { ushort [] reservedData; TagOp op; try { try { // Read kill password op = new Gen2.ReadData(Gen2.Bank.RESERVED, 0, 2); reservedData = (ushort[])objReader.ExecuteTagOp(op, filter); if (null != reservedData) { txtKillPassword.Text = ByteFormat.ToHex(ByteConv.ConvertFromUshortArray(reservedData), "", " "); } else { txtKillPassword.Text = ""; } } catch (Exception ex) { if (ex is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception) { txtKillPassword.Text = "Read Error"; } else { txtKillPassword.Text = ex.Message; } } try { // Read access password reservedData = null; op = new Gen2.ReadData(Gen2.Bank.RESERVED, 2, 2); reservedData = (ushort[])objReader.ExecuteTagOp(op, filter); if (null != reservedData) { txtAcessPassword.Text = ByteFormat.ToHex(ByteConv.ConvertFromUshortArray(reservedData), "", " "); } else { txtAcessPassword.Text = ""; } } catch (Exception ex) { if (ex is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception) { txtAcessPassword.Text = "Read Error"; } else { txtAcessPassword.Text = ex.Message; } } // Read additional memory password try { reservedData = null; if (model.Equals("M5e") || model.Equals("M5e EU") || model.Equals("M5e Compact") || model.Equals("M5e PRC") || model.Equals("Astra")) { ReadAdditionalReservedMemDataM5eVariants(Gen2.Bank.RESERVED, 4, filter, out reservedData); } else { op = new Gen2.ReadData(Gen2.Bank.RESERVED, 4, 0); reservedData = (ushort[])objReader.ExecuteTagOp(op, filter); } if (null != reservedData) { txtReservedMemUnusedValue.Text = ByteFormat.ToHex(ByteConv.ConvertFromUshortArray(reservedData), "", " "); // Visible additional memory textboxes lblAdditionalReservedMem.Visibility = System.Windows.Visibility.Visible; txtReservedMemUnusedValue.Visibility = System.Windows.Visibility.Visible; lblAdditionalReservedMemAdd.Visibility = System.Windows.Visibility.Visible; } else { txtReservedMemUnusedValue.Text = ""; } } catch { // catch the exception and move on. Only some tags has aditional memory txtReservedMemUnusedValue.Text = ""; // Hide additional memory textboxes lblAdditionalReservedMem.Visibility = System.Windows.Visibility.Collapsed; txtReservedMemUnusedValue.Visibility = System.Windows.Visibility.Collapsed; lblAdditionalReservedMemAdd.Visibility = System.Windows.Visibility.Collapsed; } } catch (Exception) { throw; } }
public void Go(string comPort, int duration, string checkBitEnable, int rangeFromReader, int angleFromReader) { Thread.Sleep(1000); Console.Clear(); Console.ForegroundColor = ConsoleColor.DarkRed; Console.WriteLine("*************** Jack Mode ENGAGED ****************"); Thread.Sleep(1000); Console.Write("Establishing connection"); for (int i = 0; i < 30; i++) { Console.Write("."); i++; Thread.Sleep(100); } Console.WriteLine("."); EM4325Tag tag = new EM4325Tag { Range = rangeFromReader, Angle = angleFromReader, Check = checkBitEnable, FullRead = false }; int[] antennaList = null; double maxTick = 0; double minTick = 100; double tBuff = 0; float goodFrame = 0; float badFrame = 0; float frameRecieved = 0; TagFilter filter0; var csv = new StringBuilder(); csv.Capacity = 1000000; // Need a nice large sized CSV file. int testDuration = duration; DateTime now = DateTime.Now; filter0 = new TagData(tag.defaultEPCHeader); Reader r = Reader.Create(comPort); try { r.Connect(); Console.WriteLine("Connection Successful"); //csv.AppendLine("Time" + "," + "X" + "," + "Y" + "," + "Z"); TagOp op = new Gen2.ReadData(Gen2.Bank.USER, tag.UserMemoryLocation, 3); if (checkBitEnable == "Y") { op = new Gen2.ReadData(Gen2.Bank.USER, tag.UserMemoryLocation, 4); } if (tag.FullRead) { op = new Gen2.ReadData(Gen2.Bank.USER, tag.UserMemoryLocation, 6); } SimpleReadPlan plan = new SimpleReadPlan(antennaList, TagProtocol.GEN2, filter0, op, true, 150); Gen2.BAPParameters bap = (Gen2.BAPParameters)r.ParamGet("/reader/gen2/bap"); bap.FREQUENCYHOPOFFTIME = 20; bap.POWERUPDELAY = 3; // r.ParamSet("/reader/gen2/Q", new Gen2.StaticQ(2)); r.ParamSet("/reader/gen2/blf", Gen2.LinkFrequency.LINK640KHZ); // this is required to get the desired speed. r.ParamSet("/reader/read/asyncOnTime", testDuration); r.ParamSet("/reader/read/asyncOffTime", 5); r.ParamSet("/reader/read/plan", plan); int checkInt1 = 0; int buffcheck = 0; double tBuffstart = 0; // Create and add tag listeners Stopwatch stopWatch = new Stopwatch(); stopWatch.Start(); r.TagRead += delegate(Object sender, TagReadDataEventArgs e) { TimeSpan tsB = stopWatch.Elapsed; tBuffstart = tsB.TotalMilliseconds; double tempV = tBuffstart - tBuff; tag.RSSI = e.TagReadData.Rssi.ToString(); tag.UserMemory = ByteFormat.ToHex(e.TagReadData.Data).ToString(); // convert the input into a hex string tag.EPC = e.TagReadData.EpcString; tag.UserMemory.Trim(); int length = 4; int substringposition = 2; // need to offset two, due to return hex eg 0x2000 if (tag.EPC == tag.defaultEPCHeader) { //SimpleReadPlan planA = new SimpleReadPlan(antennaList, TagProtocol.GEN2, filter1, op, true, 50); while (substringposition < 3) // split the string into small chunks per value and convert to INT { tag.mem1 = tag.UserMemory.Substring(substringposition, length); tag.mem1Int = Convert.ToInt32(tag.mem1, 16); substringposition = substringposition + length; tag.XString = tag.XInteger.ToString(); tag.X = tag.UserMemory.Substring(substringposition, length); tag.YInteger = Convert.ToInt32(tag.Y, 16); substringposition = substringposition + length; tag.YString = tag.YInteger.ToString(); tag.Y = tag.UserMemory.Substring(substringposition, length); tag.ZInteger = Convert.ToInt32(tag.Z, 16); substringposition = substringposition + length; tag.ZString = tag.ZInteger.ToString(); if (checkBitEnable == "Y") { tag.Check = tag.UserMemory.Substring(substringposition, length); checkInt1 = Convert.ToInt32(tag.Check, 16); substringposition = substringposition + length; buffcheck = tag.XInteger + tag.YInteger + tag.ZInteger; } } } if (checkInt1 != buffcheck && checkBitEnable == "Y") // Essentially looking to see if the total sum is correct, if not report a bad frame. { badFrame++; frameRecieved++; } if (checkInt1 == buffcheck || checkBitEnable == "N") { goodFrame++; tsB = stopWatch.Elapsed; tBuff = tsB.TotalMilliseconds; if (tempV > 0.0002) { if (tempV > maxTick) { maxTick = tempV; } if (tempV < minTick) { minTick = tempV; } } frameRecieved++; } }; Console.WriteLine(""); r.StartReading(); Thread.Sleep(testDuration); // File.WriteAllText("C:\\dmp\\testingCrap.csv", csv.ToString()); float ratio = (badFrame / frameRecieved) * 100; float ptime = testDuration / frameRecieved; float accelHZ = (goodFrame / testDuration) * 1000; Console.WriteLine("------------------------------------------"); Console.WriteLine("Summary of stats"); Console.WriteLine("Test conducted " + now.TimeOfDay); Console.WriteLine("EPC : " + tag.EPC); Console.WriteLine("------------------------------------------"); Console.WriteLine("Test Ran for : " + testDuration + " ms "); Console.WriteLine("Number of Packets recieved : " + frameRecieved); Console.WriteLine("CORRUPT Packets : " + badFrame); Console.WriteLine("GOOD Packets : " + goodFrame); Console.WriteLine("Effective Packet loss = " + ratio + " %"); Console.WriteLine("Estimated Packet time : " + ptime + " ms"); Console.WriteLine("Min Packet time : " + minTick + " ms"); Console.WriteLine("Max Packet time : " + maxTick + " ms"); Console.WriteLine("Effective Accel Update rate = " + accelHZ + " Hz"); Console.WriteLine("Reader Range " + tag.Range); Console.WriteLine("Reader Angle " + tag.Angle); csv.AppendLine("------------------------------------------"); csv.AppendLine("Summary of stats"); csv.AppendLine("Test conducted " + now.TimeOfDay); csv.AppendLine("EPC : " + tag.EPC); csv.AppendLine("------------------------------------------"); csv.AppendLine("Test Ran for : " + testDuration + " ms "); csv.AppendLine("Number of Packets recieved : " + frameRecieved); csv.AppendLine("CORRUPT Packets : " + badFrame); csv.AppendLine("GOOD Packets : " + goodFrame); csv.AppendLine("Effective Packet loss = " + ratio + " %"); csv.AppendLine("Estimated Packet time : " + ptime + " ms"); csv.AppendLine("Min Packet time : " + minTick + " ms"); csv.AppendLine("Max Packet time : " + maxTick + " ms"); csv.AppendLine("Effective Accel Update rate = " + accelHZ + " Hz"); csv.AppendLine("Reader Range " + tag.Range); csv.AppendLine("Reader Angle " + tag.Angle); r.Dispose(); Console.WriteLine(""); Console.WriteLine(""); string filename = DateTime.Now.ToString("yyyy-MM-d--HH-mm-ss--Angle--" + angleFromReader); string dateNow = @"C:\temp\" + filename + ".csv"; // The program will log data to a file with a correct Timestamp. try { File.WriteAllText(dateNow, csv.ToString()); } catch (ArgumentException e) { // Console.WriteLine("Can't write file."); Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message); } Console.WriteLine("Preparing for next run"); for (int i = 0; i < 30; i++) { Console.Write("."); i++; Thread.Sleep(100); } Console.WriteLine("."); stopWatch.Stop(); Thread.Sleep(2500); Console.Clear(); Console.WriteLine(""); } catch { Console.WriteLine("Connection Failed."); Console.WriteLine("Please retry (press any key or crtl-c to exit)"); if (Console.ReadKey() != null) { } } }
/// <summary> /// Read tag memory which has more then 64 words or 128 bytes. Returns the data read from tag memory. /// Stops reading the tag memory if FAULT_PROTOCOL_BIT_DECODING_FAILED_Exception exception is received /// more then once. If the data read from tag memory is less then 64 words then initiates reading tag /// memory word by word /// </summary> /// <param name="bank"> Gen2 memory bank</param> /// <param name="filter">filter</param> /// <param name="data">Memory data obtained from the tag</param> private void ReadLargeTagMemory(Gen2.Bank bank, TagFilter filter, ref ushort[] data) { lock (new Object()) { List <ushort> dataTemp = new List <ushort>(); if (data != null) { dataTemp.AddRange(data); } int words = 0; uint startaddress = 64; TagOp op; bool isAllDataReceived = false; while (false == isAllDataReceived) { try { op = new Gen2.ReadData(bank, startaddress, Convert.ToByte(words)); ushort[] tempDataReceived = (ushort[])objectReader.ExecuteTagOp(op, filter); dataTemp.AddRange(tempDataReceived); startaddress += 64; if (tempDataReceived.Length < 64) { isAllDataReceived = true; // If data received is less then 64 words, perform word by word with start address as length // of the data and number of words to read is 1 data = dataTemp.ToArray(); ReadTagMemoryWordByWord(bank, filter, ref data); } } catch (Exception ex) { if (ex is FAULT_PROTOCOL_BIT_DECODING_FAILED_Exception) { try { // If read is success then continue the while loop with incremented start address and length as 0 words = 64; op = new Gen2.ReadData(bank, startaddress, Convert.ToByte(words)); dataTemp.AddRange(((ushort[])objectReader.ExecuteTagOp(op, filter))); startaddress += 64; words = 0; } catch (Exception et) { // If consecutively we get FAULT_PROTOCOL_BIT_DECODING_FAILED_Exception exception blindly come out of the loop to avoid // dead lock if (et is FAULT_PROTOCOL_BIT_DECODING_FAILED_Exception) { isAllDataReceived = true; } else { throw; } } } else { throw; } } } data = dataTemp.ToArray(); } }
/// <summary> /// Read tag memory which has more then 64 words or 128 bytes. Returns the data read from tag memory. /// Stops reading the tag memory if FAULT_PROTOCOL_BIT_DECODING_FAILED_Exception exception is received /// more then once. If the data read from tag memory is less then 64 words then initiates reading tag /// memory word by word /// </summary> /// <param name="bank"> Gen2 mem bank</param> /// <param name="filter">filter</param> /// <param name="data">Mem data obtained from the tag</param> private void ReadLargeTagMemory(Gen2.Bank bank, TagFilter filter, ref ushort[] data) { lock (new Object()) { List<ushort> dataTemp = new List<ushort>(); if (data != null) { dataTemp.AddRange(data); } int words = 0; uint startaddress = 64; TagOp op; bool isAllDatareceived = true; while (isAllDatareceived) { try { op = new Gen2.ReadData(bank, startaddress, Convert.ToByte(words)); ushort[] tempDataReceived = (ushort[])objectReader.ExecuteTagOp(op, filter); dataTemp.AddRange(tempDataReceived); startaddress += 64; if (tempDataReceived.Length < 64) { isAllDatareceived = false; // If data received is less then 64 words, perform word by word with start address as length // of the data and numer of words to read is 1 ReadTagMemoryWordByWord(bank, filter, ref data); } } catch (Exception ex) { if (ex is FAULT_PROTOCOL_BIT_DECODING_FAILED_Exception) { try { // If read is success then continue the while loop with incremented start address and length as 0 words = 64; op = new Gen2.ReadData(bank, startaddress, Convert.ToByte(words)); dataTemp.AddRange(((ushort[])objectReader.ExecuteTagOp(op, filter))); startaddress += 64; words = 0; } catch (Exception et) { // If consecutively we get FAULT_PROTOCOL_BIT_DECODING_FAILED_Exception exception blindly come out of the loop to avoid // dead lock if (et is FAULT_PROTOCOL_BIT_DECODING_FAILED_Exception) { isAllDatareceived = false; } else { throw; } } } else { throw; } } } data = dataTemp.ToArray(); } }
/// <summary> /// Read tag memory word by word. If FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception /// or Non-specific reader error or General Tag Error or Tag data access failed exception /// is recieved. Memory reading is stopped and the already read data is returned /// </summary> /// <param name="bank">Gen2 memory bank</param> /// <param name="filter">Select filter</param> /// <param name="data">Read tag memory data is returned</param> private void ReadTagMemoryWordByWord(Gen2.Bank bank, TagFilter filter, ref ushort[] data) { lock (new Object()) { List<ushort> dataTemp = new List<ushort>(); uint startaddress = 0; if (data != null) { // if the data varibale already contains the data, then add that data // to data temp and chnage the start address to total data length dataTemp.AddRange(data); startaddress = (uint)data.Length; } int words = 1; TagOp op; bool isAllDatareceived = true; while (isAllDatareceived) { try { // Read tag memory word by word op = new Gen2.ReadData(bank, startaddress, Convert.ToByte(words)); dataTemp.AddRange(((ushort[])objectReader.ExecuteTagOp(op, filter))); startaddress += 1; } catch (Exception exception) { if (exception is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception || (-1 != exception.Message.IndexOf("Non-specific reader error")) || (-1 != exception.Message.IndexOf("General Tag Error")) || (-1 != exception.Message.IndexOf("Tag data access failed"))) { if (dataTemp.Count > 0) { // Just skip the exception and move on. So as not to lose the already read data. isAllDatareceived = false; } else { // throw the exception if the data received is null for the first iteration itself throw; } } else { throw; } } } data = dataTemp.ToArray(); } }
/// <summary> /// Read tag memory for readers or modules other the M5e variants /// </summary> /// <param name="bank">Gen2 memory bank</param> /// <param name="filter">filter</param> /// <param name="MemData">Data read from tag memory</param> private void ReadMemoryM6eVariants(Gen2.Bank bank, TagFilter filter, ref ushort[] MemData) { try { // Read tag memory with zero as start address and lenght of words to read as zero TagOp op = new Gen2.ReadData(bank, 0, 0); MemData = (ushort[])objectReader.ExecuteTagOp(op, filter); if (MemData.Length < 64) { // If data read is less then 64 words, then perform read word by word to make sure // all the data is read from the tag memory ReadTagMemoryWordByWord(bank, filter, ref MemData); } else { // If data read is more then 64 words then perform read with start address as 64 words // and length as zero ReadLargeTagMemory(bank, filter, ref MemData); } } catch (Exception ex) { if ((ex is FAULT_PROTOCOL_BIT_DECODING_FAILED_Exception) || ((ex is FAULT_NO_TAGS_FOUND_Exception))) { // Perform read when the tag has mem more then 128 bytes and doesn't support // Zero start address and number of words to read as zero ReadLargeTagMemoryWithoutZeroLengthSupport(bank, filter, ref MemData); } else { throw; } } }
static void Main(string[] args) { // Program setup if (1 > args.Length) { Usage(); } for (int nextarg = 1; nextarg < args.Length; nextarg++) { string arg = args[nextarg]; if (arg.Equals("--ant")) { if (null != antennaList) { Console.WriteLine("Duplicate argument: --ant specified more than once"); Usage(); } antennaList = ParseAntennaList(args, nextarg); nextarg++; } else { Console.WriteLine("Argument {0}:\"{1}\" is not recognized", nextarg, arg); Usage(); } } try { // Create Reader object, connecting to physical device. // Wrap reader in a "using" block to get automatic // reader shutdown (using IDisposable interface). using (r = Reader.Create(args[0])) { //Uncomment this line to add default transport listener. //r.Transport += r.SimpleTransportListener; r.Connect(); if (Reader.Region.UNSPEC == (Reader.Region)r.ParamGet("/reader/region/id")) { Reader.Region[] supportedRegions = (Reader.Region[])r.ParamGet("/reader/region/supportedRegions"); if (supportedRegions.Length < 1) { throw new FAULT_INVALID_REGION_Exception(); } r.ParamSet("/reader/region/id", supportedRegions[0]); } string model = (string)r.ParamGet("/reader/version/model").ToString(); if (!model.Equals("M3e")) { if (r.isAntDetectEnabled(antennaList)) { Console.WriteLine("Module doesn't has antenna detection support please provide antenna list"); Usage(); } //Use first antenna for operation if (antennaList != null) { r.ParamSet("/reader/tagop/antenna", antennaList[0]); } } else { if (antennaList != null) { Console.WriteLine("Module doesn't support antenna input"); Usage(); } } // This select filter matches all Gen2 tags where bits 32-48 of the EPC are 0x0123 #if ENABLE_FILTER TagFilter filter = new Gen2.Select(false, Gen2.Bank.EPC, 32, 16, new byte[] { 0x01, 0x23 }); #endif if (!model.Equals("M3e")) { //Gen2.TagData epc = new Gen2.TagData(new byte[] { // 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, // 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, //}); //Gen2.WriteTag tagop = new Gen2.WriteTag(epc); //r.ExecuteTagOp(tagop, null); } // Reads data from a tag memory bank after writing data to the requested memory bank without powering down of tag #if ENABLE_READ_AFTER_WRITE { //create a tagopList with write tagop followed by read tagop TagOpList tagopList = new TagOpList(); byte wordCount; ushort[] readData; //Write one word of data to USER memory and read back 8 words from EPC memory using WriteData and ReadData { ushort[] writeData = { 0x9999 }; wordCount = 8; Gen2.WriteData wData = new Gen2.WriteData(Gen2.Bank.USER, 2, writeData); Gen2.ReadData rData = new Gen2.ReadData(Gen2.Bank.EPC, 0, wordCount); //Gen2.WriteTag wTag = new Gen2.WriteTag(epc); // assemble tagops into list tagopList.list.Add(wData); tagopList.list.Add(rData); Console.WriteLine("###################Embedded Read after write######################"); // uncomment the following for embedded read after write. embeddedRead(TagProtocol.GEN2, null, tagopList); // call executeTagOp with list of tagops //readData = (ushort[])r.ExecuteTagOp(tagopList, null); //Console.WriteLine("ReadData: "); //foreach (ushort word in readData) //{ // Console.Write(" {0:X4}", word); //} //Console.WriteLine("\n"); } //clearing the list for next operation tagopList.list.Clear(); //Write 12 bytes(6 words) of EPC and read back 8 words from EPC memory using WriteTag and ReadData { Gen2.TagData epc1 = new Gen2.TagData(new byte[] { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, }); wordCount = 8; Gen2.WriteTag wtag = new Gen2.WriteTag(epc1); Gen2.ReadData rData = new Gen2.ReadData(Gen2.Bank.EPC, 0, wordCount); // assemble tagops into list tagopList.list.Add(wtag); tagopList.list.Add(rData); // call executeTagOp with list of tagops //readData = (ushort[])r.ExecuteTagOp(tagopList, null); //Console.WriteLine("ReadData: "); //foreach (ushort word in readData) //{ // Console.Write(" {0:X4}", word); //} //Console.WriteLine("\n"); } } #endif // Perform read and print UID and tagtype of tag found SimpleReadPlan plan = new SimpleReadPlan(antennaList, TagProtocol.ISO15693, null, null, 1000); r.ParamSet("/reader/read/plan", plan); TagReadData[] tagReads = r.Read(1000); Console.WriteLine("UID: " + tagReads[0].EpcString); Console.WriteLine("TagType: " + (Iso15693.TagType)(tagReads[0].TagType)); MemoryType type; MultiFilter mulfilter = null; UInt32 address; byte length; #if ENABLE_M3E_FILTER //Initialize filter // Filters the tag based on tagtype TagFilter tagTypeFilter = new Select_TagType((UInt64)((Iso15693.TagType)(tagReads[0].TagType))); // Filters the tag based on UID TagFilter uidFilter = new Select_UID(32, ByteFormat.FromHex(tagReads[0].Tag.EpcString.Substring(0, 8))); // Initialize multi filter mulfilter = new MultiFilter(new TagFilter[] { tagTypeFilter, uidFilter }); #endif #if ENABLE_M3E_BLOCK_READ_WRITE //Initialize all the fields required for Read Data Tag operation type = MemoryType.BLOCK_MEMORY; address = 0; length = 1; // Read memory before write ReadMemory bRead = new ReadMemory(type, address, length); byte[] dataRead = (byte[])r.ExecuteTagOp(bRead, mulfilter); // prints the data read Console.WriteLine("Read Data before performing block write: "); foreach (byte i in dataRead) { Console.Write(" {0:X2}", i); } Console.WriteLine("\n"); // Uncomment this to enable Embedded read memory //embeddedRead(TagProtocol.ISO15693, mulfilter, bRead); // Initialize write memory byte[] data = new byte[] { 0x11, 0x22, 0x33, 0x44 }; WriteMemory writeOp = new WriteMemory(type, address, data); // Execute the tagop r.ExecuteTagOp(writeOp, mulfilter); // Uncomment this to enable Embedded write data //embeddedRead(TagProtocol.ISO15693, mulfilter, writeOp); //Read memory after block write ReadMemory readOp = new ReadMemory(type, address, length); byte[] readData = (byte[])r.ExecuteTagOp(readOp, mulfilter); // prints the data read Console.WriteLine("Read Data after performing block write operation: "); foreach (byte i in readData) { Console.Write(" {0:X2}", i); } Console.WriteLine("\n"); #endif #if ENABLE_M3E_SYSTEM_INFORMATION_MEMORY //Get the system information of tag. Address and length fields have no significance if memory type is BLOCK_SYSTEM_INFORMATION_MEMORY. type = MemoryType.BLOCK_SYSTEM_INFORMATION_MEMORY; address = 0; length = 0; ReadMemory sysInfoOp = new ReadMemory(type, address, length); byte[] systemInfo = (byte[])r.ExecuteTagOp(sysInfoOp, mulfilter); // parsing the system info response if (systemInfo.Length > 0) { parseGetSystemInfoResponse(systemInfo); } #endif #if ENABLE_M3E_SECURE_ID // Read secure id of tag. Address and length fields have no significance if memory type is SECURE_ID. type = MemoryType.SECURE_ID; address = 0; length = 0; ReadMemory secureIdOp = new ReadMemory(type, address, length); byte[] rspData = (byte[])r.ExecuteTagOp(secureIdOp, mulfilter); // parse secure id operation response. if (rspData.Length > 0) { parseSecureIdResponse(rspData); } #endif #if ENABLE_M3E_BLOCK_PROTECTION_STATUS // Get the block protection status of block 0. type = MemoryType.BLOCK_PROTECTION_STATUS_MEMORY; address = 0; length = 1; ReadMemory blkProtectionOp = new ReadMemory(type, address, length); byte[] statusData = (byte[])r.ExecuteTagOp(blkProtectionOp, mulfilter); // parse the block protection status response. if (statusData.Length == length) { parseGetBlockProtectionStatusResponse(statusData, address, length); } #endif } } catch (ReaderException re) { Console.WriteLine("Error: " + re.Message); } catch (Exception ex) { Console.WriteLine("Error: " + ex.Message); } }
/// <summary> /// Read tag memory when tag has more then 64 words or 128 bytes. And module doesn't supports zero address and zero length. /// Reads the tag memory with 0 address and length of words as 64. If memory overrun received. Initiates reading of tag /// word by word with start address as length of alread read data and length of words to read as 0. Returns the data read from /// tag memory. /// </summary> /// <param name="bank">Gen2 mem bank</param> /// <param name="filter">filter</param> /// <param name="data">Data read from tag memory</param> private void ReadLargeTagMemoryWithoutZeroLengthSupport(Gen2.Bank bank, TagFilter filter, ref ushort[] data) { lock (new Object()) { data = null; // Data from tag memory List<ushort> dataTemp = new List<ushort>(); // Number of words to read int words = 64; // Start address uint startaddress = 0; TagOp op; bool isAllDatareceived = true; // Read till all the data from the tag memory is read while (isAllDatareceived) { try { op = new Gen2.ReadData(bank, startaddress, Convert.ToByte(words)); dataTemp.AddRange(((ushort[])objectReader.ExecuteTagOp(op, filter))); // Increment the start address to 64 and keep length of wrods to read as 64 for // all the iterations startaddress += 64; } catch (Exception ex) { try { if (ex is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception || (-1 != ex.Message.IndexOf("Non-specific reader error")) || (-1 != ex.Message.IndexOf("General Tag Error")) || (-1 != ex.Message.IndexOf("Tag data access failed"))) { // If the memory to read requested is more then the available memory in the tag, then initiate // reading the tag memory word by word with start address as length of already read data if exists // and lenght of words to read is 1 ushort[] wordData = null; if (dataTemp.Count > 0) { // If some data is already read then include this data also so that // reading of memory doesn't continue from zero and the list sholud // not contain same data twice wordData = dataTemp.ToArray(); } ReadTagMemoryWordByWord(bank, filter, ref wordData); dataTemp.AddRange(wordData); // Come out of main while loop. And read the already read data isAllDatareceived = false; } else { throw; } } catch (Exception exception) { // If more then once the below exceptions are recieved then come out of the loop. if (exception is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception || (-1 != exception.Message.IndexOf("Non-specific reader error")) || (-1 != exception.Message.IndexOf("General Tag Error")) || (-1 != exception.Message.IndexOf("Tag data access failed"))) { if (dataTemp.Count > 0) { // Just skip the exception and move on. So as not to lose the already read data. isAllDatareceived = false; } else { // throw the exception if the data received is null for the first iteration itself throw; } } else { throw; } } } } data = dataTemp.ToArray(); } }
static void Main(string[] args) { try { // connect to and initialize reader Reader reader = Common.EstablishReader(); // setup sensor activation commands and filters ensuring On-Chip RSSI Min Filter is applied Gen2.Select tempsensorEnable = Common.CreateGen2Select(4, 4, Gen2.Bank.TID, 0x00, 16, new byte[] { (byte)0xE2, (byte)0x82 }); Gen2.Select ocrssiMinFilter = Common.CreateGen2Select(4, 0, Gen2.Bank.USER, 0xA0, 8, new byte[] { (byte)(0x20 | ocrssiMin - 1) }); Gen2.Select ocrssiMaxFilter = Common.CreateGen2Select(4, 2, Gen2.Bank.USER, 0xA0, 8, new byte[] { ocrssiMax }); MultiFilter selects = new MultiFilter(new Gen2.Select[] { tempsensorEnable, ocrssiMinFilter, ocrssiMaxFilter }); Gen2.ReadData operation; if (moistureMode) { // read parameters for moisture code operation = new Gen2.ReadData(Gen2.Bank.RESERVED, 0xB, (byte)1); } else { // read parameters for on-chip RSSI code operation = new Gen2.ReadData(Gen2.Bank.RESERVED, 0xD, (byte)1); } // create configuration SimpleReadPlan config = new SimpleReadPlan(Common.antennas, TagProtocol.GEN2, selects, operation, 1000); reader.ParamSet("/reader/read/plan", config); for (int i = 1; i <= readAttempts; i++) { Console.WriteLine("Read Attempt #" + i); // attempt to read sensor tags TagReadData[] results = reader.Read(Common.readTime); if (results.Length != 0) { foreach (TagReadData tag in results) { String epc = tag.EpcString; Console.WriteLine("* EPC: " + epc); byte[] dataBytes = tag.Data; short[] dataWords = Common.ConvertByteArrayToShortArray(dataBytes); if (dataWords.Length != 0) { if (moistureMode) { Console.WriteLine(" - Moisture: " + dataWords[0] + " at " + tag.Frequency + " kHz"); } else { Console.WriteLine(" - On-Chip RSSI: " + dataWords[0]); } } } } else { Console.WriteLine("No tag(s) found"); } Console.WriteLine(); } } catch (Exception e) { Console.WriteLine("Error: " + e.ToString()); Environment.Exit(-1); } }
static void Main(string[] args) { // Program setup if (1 != args.Length) { Console.WriteLine(String.Join("\r\n", new string[] { "Please provide reader URL, such as:", "tmr:///com4", "tmr://my-reader.example.com", })); Environment.Exit(1); } try { // Create Reader object, connecting to physical device. // Wrap reader in a "using" block to get automatic // reader shutdown (using IDisposable interface). using (Reader r = Reader.Create(args[0])) { //Uncomment this line to add default transport listener. //r.Transport += r.SimpleTransportListener; r.Connect(); if ((r is SerialReader) || (r is LlrpReader)) { if (Reader.Region.UNSPEC == (Reader.Region)r.ParamGet("/reader/region/id")) { Reader.Region[] supportedRegions = (Reader.Region[])r.ParamGet("/reader/region/supportedRegions"); if (supportedRegions.Length < 1) { throw new FAULT_INVALID_REGION_Exception(); } else { r.ParamSet("/reader/region/id", supportedRegions[0]); } } Gen2.Password pass = new Gen2.Password(0x0); r.ParamSet("/reader/gen2/accessPassword", pass); // BlockWrite and read using ExecuteTagOp Gen2.BlockWrite blockwrite = new Gen2.BlockWrite(Gen2.Bank.USER, 0, new ushort[] { 0xFFF1, 0x1122 }); r.ExecuteTagOp(blockwrite, null); Gen2.ReadData read = new Gen2.ReadData(Gen2.Bank.USER, 0, 2); ushort[] readData = (ushort[])r.ExecuteTagOp(read, null); foreach (ushort word in readData) { Console.Write(String.Format(" {0:X4}", word)); } Console.WriteLine(); // BlockWrite and read using embedded read command SimpleReadPlan readplan; TagReadData[] tagreads; blockwrite = new Gen2.BlockWrite(Gen2.Bank.USER, 0, new ushort[] { 0x1234, 0x5678 }); readplan = new SimpleReadPlan(null, TagProtocol.GEN2, //null, new TagData("1234567890ABCDEF"), blockwrite, 0); r.ParamSet("/reader/read/plan", readplan); r.Read(500); readplan = new SimpleReadPlan(null, TagProtocol.GEN2, null, new Gen2.ReadData(Gen2.Bank.USER, 0, 2), 0); r.ParamSet("/reader/read/plan", readplan); tagreads = r.Read(500); foreach (TagReadData trd in tagreads) { foreach (byte b in trd.Data) { Console.Write(String.Format(" {0:X2}", b)); } Console.WriteLine(" " + trd.ToString()); } } else { Console.WriteLine("Error: This codelet works only for Serial Readers and Llrp Readers"); } } } catch (ReaderException re) { Console.WriteLine("Error: " + re.Message); } catch (Exception ex) { Console.WriteLine("Error: " + ex.Message); } }
static void Main(string[] args) { try { // connect to and initialize reader Reader reader = Common.EstablishReader(); // setup sensor activation commands and filters ensuring On-Chip RSSI Min Filter is applied Gen2.Select globalEnable = Common.CreateGen2Select(4, 2, Gen2.Bank.USER, 0x3B0, 8, new byte[] { (byte)0x00 }); Gen2.Select ocrssiMinFilter = Common.CreateGen2Select(4, 0, Gen2.Bank.USER, 0x3D0, 8, new byte[] { (byte)(0x20 | ocrssiMin - 1) }); Gen2.Select ocrssiMaxFilter = Common.CreateGen2Select(4, 2, Gen2.Bank.USER, 0x3D0, 8, new byte[] { ocrssiMax }); MultiFilter selects = new MultiFilter(new Gen2.Select[] { globalEnable, ocrssiMinFilter, ocrssiMaxFilter }); // parameters to read all three sensor codes at once Gen2.ReadData operation = new Gen2.ReadData(Gen2.Bank.RESERVED, 0xA, (byte)5); // create configuration SimpleReadPlan config = new SimpleReadPlan(Common.antennas, TagProtocol.GEN2, selects, operation, 1000); for (int i = 1; i <= readAttempts; i++) { Console.WriteLine("\nRead Attempt #" + i); // optimize settings for reading sensors reader.ParamSet("/reader/read/plan", config); reader.ParamSet("/reader/gen2/t4", (UInt32)9000); // CW delay in microseconds reader.ParamSet("/reader/gen2/session", Common.session); reader.ParamSet("/reader/gen2/q", new Gen2.DynamicQ()); // attempt to read sensor tags TagReadData[] results = reader.Read(Common.readTime); reader.ParamSet("/reader/gen2/t4", (UInt32)300); reader.ParamSet("/reader/gen2/session", Gen2.Session.S0); reader.ParamSet("/reader/gen2/q", new Gen2.StaticQ(0)); if (results.Length != 0) { foreach (TagReadData tag in results) { String epc = tag.EpcString; Console.WriteLine("* EPC: " + epc); byte[] dataBytes = tag.Data; short[] dataWords = Common.ConvertByteArrayToShortArray(dataBytes); if (dataWords.Length != 0) { int backport1Code = dataWords[0]; int backport2Code = dataWords[1]; int moistureCode = dataWords[2]; int ocrssiCode = dataWords[3]; int temperatureCode = dataWords[4]; // On-Chip RSSI Sensor Console.WriteLine(" - On-Chip RSSI: " + ocrssiCode); // Moisture Sensor String moistureStatus; if (ocrssiCode < 5) { moistureStatus = "power too low"; } else if (ocrssiCode > 21) { moistureStatus = "power too high"; } else { moistureStatus = moistureCode + " at " + tag.Frequency + " kHz"; } Console.WriteLine(" - Moisture: " + moistureStatus); // Temperature Sensor String temperatureStatus; if (ocrssiCode < 5) { temperatureStatus = "power too low"; } else if (ocrssiCode > 18) { temperatureStatus = "power too high"; } else if (temperatureCode < 1000 || 3500 < temperatureCode) { temperatureStatus = "bad read"; } else { try { // read, decode and apply calibration one tag at a time short[] calibrationWords = Common.ReadMemBlockByEpc(reader, tag, Gen2.Bank.USER, 0x12, 4); TemperatureCalibration cal = new TemperatureCalibration(calibrationWords); if (cal.valid) { double temperatureValue = cal.slope * temperatureCode + cal.offset; temperatureStatus = temperatureValue.ToString("0.00") + " degC"; } else { temperatureStatus = "invalid calibration"; } } catch (Exception) { temperatureStatus = "failed to read calibration"; } } Console.WriteLine(" - Temperature: " + temperatureStatus); // Backport 1 Sensor String backport1Status; if (ocrssiCode < 5) { backport1Status = "power too low"; } else if (ocrssiCode > 18) { backport1Status = "power too high"; } else { backport1Status = backport1Code + ""; } Console.WriteLine(" - Backport 1: " + backport1Status); // Backport 1 Sensor String backport2Status; if (ocrssiCode < 5) { backport2Status = "power too low"; } else if (ocrssiCode > 18) { backport2Status = "power too high"; } else { backport2Status = backport2Code + ""; } Console.WriteLine(" - Backport 2: " + backport2Status); } } } else { Console.WriteLine("No tag(s) found"); } Console.WriteLine(); } } catch (Exception e) { Console.WriteLine("Error: " + e.ToString()); Environment.Exit(-1); } }
public ReadPlan LoadSimpleReadPlan(string valstr) { Object value = ParseValue(valstr); string str = string.Empty; //Reamoves leading string for ex: SimpleReadPlan: str = valstr.Remove(0, 15); SimpleReadPlan srp = new SimpleReadPlan(); //Regular expression to remove leading and trailing square brackets string remove = Regex.Replace(str, @"]$|^\[", ""); //Regular expression to split the string string[] lines = Regex.Split(remove, @",(?![^\[\]]*\])"); TagFilter tf = null; TagOp op = null; foreach (string line in lines) { if (-1 != line.IndexOf("Antennas")) { ArrayList list = new ArrayList(); int[] antList = null; object value1 = ParseValue(line.Split('=')[1]); if (value1 != null) { antList = (int[])((ArrayList)value1).ToArray(typeof(int)); } srp.Antennas = antList; } else if (-1 != line.IndexOf("Protocol")) { srp.Protocol = (TagProtocol)Enum.Parse(typeof(TagProtocol), line.Split('=')[1], true); } else if (-1 != line.IndexOf("Filter")) { string filterData = line.Split('=')[1]; if (-1 != filterData.IndexOf("Gen2.Select")) { str = line.Remove(0, 19); //Regular expression to remove leading and trailing square brackets str = Regex.Replace(str, @"]$|^\[", ""); //Regular expression to split the string string[] select = Regex.Split(str, @"[ ,;]+"); bool Invert = false; Gen2.Bank bank = Gen2.Bank.EPC; uint BitPointer = 0; ushort BitLength = 0; byte[] mask = null; if (select.Length != 5) { throw new Exception("Invalid number of arguments for ReadPlan filter"); } foreach (string arg in select) { if (-1 != arg.IndexOf("Invert")) { Invert = Convert.ToBoolean(arg.Split('=')[1]); } else if (-1 != arg.IndexOf("Bank")) { bank = (Gen2.Bank)Enum.Parse(typeof(Gen2.Bank), arg.Split('=')[1], true); } else if (-1 != arg.IndexOf("BitPointer")) { BitPointer = Convert.ToUInt32(arg.Split('=')[1]); } else if (-1 != arg.IndexOf("BitLength")) { BitLength = Convert.ToUInt16(arg.Split('=')[1]); } else if (-1 != arg.IndexOf("Mask")) { mask = StringToByteArray(arg.Split('=')[1]); } else { throw new Exception("Invalid Argument in ReadPlan"); } } tf = new Gen2.Select(Invert, bank, BitPointer, BitLength, mask); } else if (-1 != filterData.IndexOf("EPC")) { str = line.Remove(0, 15); str = Regex.Replace(str, @"]$|^\[", ""); tf = new TagData(StringToByteArray((str.Split('=')[1]))); } else { if (!filterData.Equals("null")) { throw new Exception("Invalid Argument in ReadPlan"); } } } else if (-1 != line.IndexOf("Op")) { string tagOpData = line.Split('=')[1]; if (tagOpData != null) { if (-1 != tagOpData.IndexOf("ReadData")) { str = line.Remove(0, 12); //Regular expression to remove leading and trailing square brackets str = Regex.Replace(str, @"]$|^\[", ""); //Regular expression to split the string string[] select = Regex.Split(str, @"[ ,;]+"); Gen2.Bank bank = Gen2.Bank.EPC; uint wordAddress = 0; byte length = 0; foreach (string arg in select) { if (-1 != arg.IndexOf("Bank")) { bank = (Gen2.Bank)Enum.Parse(typeof(Gen2.Bank), arg.Split('=')[1], true); } else if (-1 != arg.IndexOf("WordAddress")) { wordAddress = Convert.ToUInt32(arg.Split('=')[1]); } else if (-1 != arg.IndexOf("Len")) { length = Convert.ToByte(arg.Split('=')[1]); } else { throw new Exception("Invalid Argument in ReadPlan TagOp"); } } op = new Gen2.ReadData(bank, wordAddress, length); } else { if (!tagOpData.Equals("null")) { throw new Exception("Invalid Argument in ReadPlan"); } } } } else if (-1 != line.IndexOf("UseFastSearch")) { srp.UseFastSearch = Convert.ToBoolean(line.Split('=')[1]); } else if (-1 != line.IndexOf("Weight")) { srp.Weight = Convert.ToInt32(lines[5].Split('=')[1]); } else { throw new Exception("Invalid Argument in ReadPlan"); } } srp.Filter = tf; srp.Op = op; return(srp); }