mprreader.cs

WJ Communications RFID example code

		/// <returns>1 if successful; otherwise 0</returns>
		public int Class0PlusErase(TagFilter filter, byte page)
		{
			byteList Params = new byteList(
				new byte[] { ActiveAntenna, TxPower, Class0SingulationField, page} );

			Params.Add(filter.Length);
			Params.Add(filter.Bits);

			MPRMsg aMsg = comm.Send(CmdCode.Class0PlusErasePage, Params);

			if (!ProcMsgStat(aMsg))
				return 0;

			return ProcessSummary(aMsg.DataBytes.subList(aMsg.DataBytes.Count - 6));
		}
		
		#endregion

		#region Zuma SubCommands
		/// <summary>
		/// Zuma subcommand to Program an EPC and KillPasscode into a tag.
		/// </summary>
		/// <param name="options"></param>
		/// <param name="tagID"></param>
		/// <param name="killPasscode"></param>
		/// <returns></returns>
		public int Class0ZumaProgramEPC(ZumaProgramOptions options, byteList tagID, byteList killPasscode)
		{
			byteList Params = new byteList(
				new byte[] { ActiveAntenna, TxPower, (byte)options,
							   (byte)Class0ZumaSubcommands.ProgramEPC } );

			Params.Add((byte)(tagID.Count * 8));	// tagID length in bits
			Params.Add(tagID.ToArray());
			Params.Add(killPasscode.ToArray());

			MPRMsg aMsg = comm.Send(CmdCode.Class0ZumaCommands, Params);

			if (!ProcMsgStat(aMsg))
				return 0;

			return ProcessSummary(aMsg.DataBytes.subList(aMsg.DataBytes.Count - 6));
		}

		/// <summary>
		/// Zuma command to Read a row of data (or Tag ID).
		/// </summary>
		/// <param name="row"></param>
		/// <param name="filter"></param>
		/// <returns></returns>
		public int Class0ZumaRowRead(ref ZumaRow row, TagFilter filter)
		{
			// Must have exactly 3 data bytes in RowData.
			//			if (row == null) return false;

			// Rows between 0 and 15
			if (row.RowNumber > 15) return 0;

			byteList Params = new byteList(
				new byte[] { ActiveAntenna, TxPower, Class0SingulationField, 
							   (byte)Class0ZumaSubcommands.ReadRow } );

			Params.Add(row.RowNumber);
			Params.Add(filter.Length);
			Params.Add(filter.Bits);

			MPRMsg aMsg = comm.Send(CmdCode.Class0ZumaCommands, Params);

			if (!ProcMsgStat(aMsg))
				return 0;

			return Class0ZumaRowParse(ref row, aMsg.DataBytes);
		}

		/// <summary>
		/// Zuma command to Write a row of data (or Tag ID).
		/// </summary>
		/// <param name="row"></param>
		/// <param name="filter"></param>
		/// <param name="Ack"></param>
		/// <returns>int : # Tags written</returns>
		public int Class0ZumaRowWrite(ZumaRow row, TagFilter filter, bool Ack)
		{
			// Rows between 0 and 15
			if (row.RowNumber > 15) return 0;

			byteList Params = new byteList(
				new byte[] { ActiveAntenna, TxPower, Class0SingulationField, (byte)((Ack) ? 
							   Class0ZumaSubcommands.WriteAck :
							   Class0ZumaSubcommands.WriteRow) } );

			Params.Add(row.RowNumber);
			Params.Add(row.ToArray);
			Params.Add(filter.Length);
			Params.Add(filter.Bits);

			MPRMsg aMsg = comm.Send(CmdCode.Class0ZumaCommands, Params);

			if (!ProcMsgStat(aMsg))
				return 0;

			return ProcessSummary(aMsg.DataBytes.subList(aMsg.DataBytes.Count - 6));
		}

		/// <summary>
		/// Zuma command to Initialize a tag.
		/// </summary>
		/// <param name="filter"></param>
		/// <param name="SetLock">Whether or not to set the lock bit</param>
		/// <returns>The number of Tags the responded to the INIT</returns>
		public int Class0ZumaInit(TagFilter filter, bool SetLock)
		{
			byteList Params = new byteList(
				new byte[] { ActiveAntenna, TxPower, Class0SingulationField, 
							   (byte)Class0ZumaSubcommands.INIT } );

			Params.Add((byte)(SetLock?1:0));
			Params.Add(filter.Length);
			Params.Add(filter.Bits);

			// Send message
			MPRMsg aMsg = comm.Send(CmdCode.Class0ZumaCommands, Params);

			if (!ProcMsgStat(aMsg))
				return 0;

			return ProcessSummary(aMsg.DataBytes.subList(aMsg.DataBytes.Count - 6));
		}
		#endregion

		/// <summary>
		/// Kills a Class 0 Tag.
		/// </summary>
		/// <param name="TagIDBits">The TagID of the Class 0 tag to Kill.</param>
		/// <param name="KillPasscode">The 24-bit Passcode of the Class 0 tag to Kill.</param>
		/// <returns></returns>
		public bool Class0Kill(byteList TagIDBits, uint KillPasscode)
		{ return Class0Kill(TagIDBits, new byteList(new byte[] {(byte)(KillPasscode >> 16), (byte)(KillPasscode >> 8), (byte)KillPasscode})); }

		/// <summary>
		/// Kill a Class 0 Tag
		/// </summary>
		/// <param name="TagIDBits">The 64 or 96 ID bits of a Class 0 tag to kill.</param>
		/// <param name="KillPasscode">24 bit Kill Passcode of tag to kill.</param>
		/// <returns></returns>
		public bool Class0Kill(byteList TagIDBits, byteList KillPasscode)
		{
			// TagIDBits must be a complete 8 or 12 byte ePC Tag ID
			if ((TagIDBits.Count != 8) && (TagIDBits.Count != 12))
				return false;

			// Kill Passcode must be exactly three bytes (24 bits)
			if (KillPasscode.Count != 3)
				return false;

			byteList Params = new byteList(
				new byte[] { ActiveAntenna, TxPower, Class0SingulationField } );

			// Add the 3-byte (24-bit) Kill Passcode
			Params.Add(KillPasscode);
			Params.Add(TagIDBits);

			// Send message
			MPRMsg aMsg = comm.Send(CmdCode.Class0Kill, Params);

			// There should be exactly one response data byte, equal to 1 if tag was killed; otherwise 0
			return (ProcMsgStat(aMsg) && (aMsg.DataBytes.Count == 1) && (aMsg.DataBytes[0] == 1));		
		}
		#endregion

		#region Class1 Commands
		/// <summary>
		/// Kill Class1 Tag.
		/// TagID represented as a byteList.
		/// </summary>
		/// <param name="TagIDBits">The bits to match to singulate the Tag to kill.</param>
		/// <param name="Passcode">The Kill Passcode of the Tag to kill.  Must be 8 or 12 bytes long.</param>
		/// <returns>true if MPR responds as expected; false if invalid TagIDBits.Length, or MPR responds oddly.</returns>
		public bool Class1Kill(byteList TagIDBits, byte Passcode)
		{
			// TagIDBits must be a complete 8 or 12 byte ePC Tag ID
			if ((TagIDBits.Count != 8) && (TagIDBits.Count != 12))
				return false;

			byteList Params = new byteList(
				new byte[] { ActiveAntenna, TxPower } );

			Params.Add(Passcode);
			Params.Add(TagIDBits);

			// Send message
			MPRMsg aMsg = comm.Send(CmdCode.Class1Kill, Params);

			// There should be no response data
			return (ProcMsgStat(aMsg) && (aMsg.DataBytes.Count == 0));	
		}

		/// <summary>
		/// Program Class1 Tag.
		/// TagID represented as a byteList.
		/// The kill Passcode is also programmed, and is 1 byte
		/// </summary>
		/// <param name="TagID"></param>
		/// <param name="killPasscode"></param>
		/// <param name="options"></param>
		/// <returns></returns>
		public bool Class1ProgramID(byteList TagID, byte killPasscode, byte options)
		{
			byteList Params = new byteList(
				new byte[] { ActiveAntenna, TxPower, options } );
			
			Params.Add(TagID);
			Params.Add(killPasscode);

			MPRMsg aMsg = comm.Send(CmdCode.Class1ProgramID, Params);
			return (ProcMsgStat(aMsg));
		}

		/// <summary>
		/// Write 16 bits to a Class1 Tag.
		/// Word Addresses address 16 bits.
		/// </summary>
		/// <param name="WordAddress">The word Address.</param>
		/// <param name="Word">The 16-bit value with which to program the tag.</param>
		/// <returns>true if MPR responds properly; otherwise false.</returns>
		public bool Class1Write(byte WordAddress, ushort Word)
		{
			return Class1Write(WordAddress, (byte)(Word >> 8), (byte)(Word));
		}

		/// <summary>
		/// Write 16 bits to a Class1 Tag.
		/// Word Addresses address 16 bits.
		/// </summary>
		/// <param name="WordAddress">The word Address.</param>
		/// <param name="MSB">Most Significant byte to program the tag.</param>
		/// <param name="LSB">Least Significant byte to program the tag.</param>
		/// <returns>true if MPR responds properly; otherwise false.</returns>
		public bool Class1Write(byte WordAddress, byte MSB, byte LSB)
		{
			byteList Params = new byteList(
				new byte[] { ActiveAntenna, TxPower, (byte)(WordAddress * 16), MSB, LSB } );

			// Send message
			MPRMsg aMsg = comm.Send(CmdCode.Class1Write, Params);

			// There should be no response data
			return (ProcMsgStat(aMsg) && aMsg.DataBytes.Count == 0);	
		}

		/// <summary>
		/// Read all bits of a Class1 tag's EPC and CRC.
		/// </summary>
		/// <returns>A Class 1 Tag with its data and CRC populated with the read data.  null if no tag read.</returns>
		public RFIDTag Class1Verify()
		{
			byteList Params = new byteList(
				new byte[] { ActiveAntenna, TxPower } );

			// Send message
			MPRMsg aMsg = comm.Send(CmdCode.Class1IDVerify, Params);

			if (!ProcMsgStat(aMsg))
				return null;

			// Process response data
			return Class1VerifyParse(aMsg.DataBytes);
		}

		/// <summary>
		/// Erase a Class1 Tag.
		/// Sets all bits of identifier, CRC and Passcode to all 0s.
		/// </summary>
		/// <returns>true if MPR Responded properly; otherwise false.</returns>
		public bool Class1Erase()
		{
			byteList Params = new byteList(
				new byte[] { ActiveAntenna, TxPower } );

			// Send message
			MPRMsg aMsg = comm.Send(CmdCode.Class1IDErase, Params);

			// There should be no response data
			return (ProcMsgStat(aMsg) && (aMsg.DataBytes.Count == 0));	
		}
		#endregion

		#region Gen2 Commands
		#region Access Commands
		/// <summary>
		/// Read from Gen2 Tag Memory Bank.
		/// </summary>
		/// <param name="sel">SL bit set to: SL, Not SL or Either.</param>
		/// <param name="session">Which session to use for inventory.</param>
		/// <param name="target">Target tags with session inventoried bit set to A or B.</param>
		/// <param name="startingQ">Sets Q parameter for first inventory round.</param>
		/// <param name="accessPassword">32-bit access password.  If none in tag, set to 0x00000000.</param>
		/// <param name="memBank">Which memory bank to read from.</param>
		/// <param name="wordPointer">16-bit word address at which to start reading.</param>
		/// <param name="wordCount">Number of 16-bit words to read.</param>
		/// <returns>An Inventory of Tags, the Data section of which includes the data which was read.</returns>
		public Inventory Gen2Read(byte sel, byte session, byte target, byte startingQ, uint accessPassword, 
			byte memBank, ushort wordPointer, byte wordCount)
		{
			TagsRead = new Inventory();

			byteList Params = new byteList((byte)Gen2Subcommands.Read, ActiveAntenna, TxPower, sel, session, target, startingQ);

			Params.Add(accessPassword);

			Params.Add(memBank);
			Params.Add(wordPointer);
			Params.Add(wordCount);

			MPRMsg aMsg = comm.Send(CmdCode.Gen2Command, Params);

			if (!ProcMsgStat(aMsg))
				return null;

			return Gen2AccessParse(aMsg.DataBytes);
		}

		/// <summary>
		/// Inventory all Tags matching the Selection and Query criteria, and, to each, write data to the requested memory bank. 
		/// An option selects between using the (optional) Gen 2 Block Write command instead of Write.
		/// </summary>
		/// <param name="sel">SL bit set to: SL, Not SL or Either.</param>
		/// <param name="session">Which session to use for inventory.</param>
		/// <param name="target">Target tags with session inventoried bit set to A or B.</param>
		/// <param name="startingQ">Sets Q parameter for first inventory round.</param>
		/// <param name="accessPassword">32-bit access password.  If none in tag, set to 0x00000000.</param>
		/// <param name="options">Options specifying whether to use optional BlockWrite or BlockErase.</param>
		/// <param name="lockOptions">Options specifying whether to lock the memory bank being written.</param>
		/// <param name="memBank">Which memory bank to write to.</param>
		/// <param name="wordPointer">16-bit word address at which to start writing.</param>
		/// <param name="wordCount">Number of 16-bit words to write.</param>
		/// <param name="data">The words to write.</param>
		/// <returns>An Inventory of Tags, the Data section of which includes the result of the write.</returns>
		public Inventory Gen2Write(byte sel, byte session, byte target, byte startingQ, uint accessPassword, 
			byte options, byte lockOptions, byte memBank, ushort wordPointer, byte wordCount, byteList data)
		{
			TagsRead = new Inventory();

			byteList Params = new byteList((byte)Gen2Subcommands.Write, ActiveAntenna, TxPower, sel, session, target, startingQ);

			Params.Add(accessPassword);

			Params.Add(options, lockOptions, memBank);
			Params.Add(wordPointer);
			Params.Add(wordCount);
			Params.Add(data);

			MPRMsg aMsg = comm.Send(CmdCode.Gen2Command, Params);

			if (!ProcMsgStat(aMsg))
				return null;

			return Gen2AccessParse(aMsg.DataBytes);
		}

		/// <summary>
		/// Inventory all Tags matching the Selection and Query criteria, and block erase the requested memory bank words.
		/// </summary>
		/// <param name="sel">SL bit set to: SL, Not SL or Either.</param>
		/// <param name="session">Which session to use for inventory.</param>
		/// <param name="target">Target tags with session inventoried bit set to A or B.</param>
		/// <param name="startingQ">Sets Q parameter for first inventory round.</param>
		/// <param name="accessPassword">32-bit access password.  If none in tag, set to 0x00000000.</param>
		/// <param name="memBank">Which memory bank to erase.</param>
		/// <param name="wordPointer">16-bit word address at which to start erasing.</param>
		/// <param name="wordCount">Number of 16-bit words to erase.</param>
		/// <returns>An Inventory of Tags, the Data section of which includes the result of the erase.</returns>
		public Inventory Gen2Erase(byte sel, byte session, byte target, byte startingQ, uint accessPassword, 
			byte memBank, ushort wordPointer, byte wordCount)
		{
			TagsRead = new Inventory();

			byteList Params = new byteList((byte)Gen2Subcommands.Erase, ActiveAntenna, TxPower, sel, session, target, startingQ);

			Params.Add(accessPassword);

			Params.Add(memBank);
			Params.Add(wordPointer);
			Params.Add(wordCount);

			MPRMsg aMsg = comm.Send(CmdCode.Gen2Command, Params);

			if (!ProcMsgStat(aMsg))
				return null;

			return Gen2AccessParse(aMsg.DataBytes);
		}


		/// <summary>
		/// Inventory all Tags matching the Selection and Query criteria, and perform the requested memory bank locking actions.