mprframe.cs

WJ Communications RFID example code

//==========================================================================================
//
//	WJ.MPR.Reader.MPRFrame
//	Copyright (c) 2006, WJ Communications, Inc.
//
//==========================================================================================
using System;
using WJ.MPR.Util;

namespace WJ.MPR.Reader
{
	/// <summary>
	///	The basic unit of communications between the host and the MPR.
	///		
	///	Request Frames are sent from Host to MPR, and Response Frames are received by the Host from the MPR.  
	///
	///	Both Types of frames have a similar format:
	///
	///		[SOF][Payload]
	///		[SOF] = 0x01
	///
	///	For Request Frames:
	///		[Payload] = [NodeAddress][Length][Command][Data][CRC]
	///
	///	For Response Frames:
	///		[Payload] = [NodeAddress][Length][Status][Data][CRC]
	/// </summary>
	public class MPRFrame
	{
		private byteList FrameBytes = new byteList();
		private byteList Payload { get { return FrameBytes.subList(1, FrameBytes.Count - 2); } }
		private byteList dataBytes;

		/// <summary>
		/// Converts the Frame to a string of Hexadecimal digits
		/// </summary>
		/// <returns>string of HEX digits</returns>
		public string ToHexString() { return FrameBytes.ToHexString(); }

		/// <summary>
		/// Converts the Frame to an array of bytes
		/// </summary>
		/// <returns>the bytes in the Frame</returns>
		public byte[] ToArray() { return FrameBytes.ToArray(); }

		/// <summary>
		/// Data Field, Frame[4] to Frame[Length-2]
		/// </summary>
		public byteList Data { get { return FrameBytes.subList(4, FrameBytes.Count - 2); } }

		/// <summary>
		/// Node Address Field, Frame[1]
		/// Should always be 0
		/// </summary>
		public byte NodeAddress { get { return FrameBytes[1]; } }

		/// <summary>
		/// Length Field, Frame[2].
		/// Length of all bytes in Frame except SOF
		/// </summary>
		public byte Length { get { return (FrameBytes.Count >= 3)?FrameBytes[2]:(byte)0; } }

		/// <summary>
		/// (Request Frames Only) Command Field, Frame[3] - see CmdCode Enumeration
		/// </summary>
		public CmdCode Command { get { return (FrameBytes.Count >= 3)?(CmdCode)FrameBytes[3]:CmdCode.unknown; } }

		/// <summary>
		/// (Response Frames Only) Status Field, Frame[3] - see StatusCode Enumeration
		/// </summary>
		public StatusCode Status { get { return (FrameBytes.Count >= 3)?(StatusCode)FrameBytes[3]:StatusCode.unknown; } }

		/// <summary>
		/// crc Field, Frame[Length-2] and Frame[Length-1]
		/// </summary>
		public ushort crc { get { return (FrameBytes.Count >= 2)?Helpers.b2us(FrameBytes[FrameBytes.Count-2], FrameBytes[FrameBytes.Count-1]):(ushort)0; } }

		/// <summary>
		/// Bytes are ignored (inFrame = false) until a SOF byte received
		/// then bytes are stored (inFrame = true)
		/// </summary>
		public bool inFrame = false;

		/// <summary>
		/// bytes are added (CompleteFrame = false),
		/// until a complete frame has been received (Count = Length + 1) and can be processed. (CompleteFrame = true)
		/// </summary>
		public bool CompleteFrame = false;

		/// <summary>
		/// After a Complete Frame has been received it is processed.
		/// After processing, Processed is set to true
		/// </summary>
		public bool Processed = false;

		/// <summary>
		/// Add a byte to the frame.
		/// bytes are ignored until SOF = true.
		/// when Count == Length + 1, A complete Frame has been received and is ready for processing
		/// </summary>
		/// <param name="b">the byte to add</param>
		public void Add(byte b)
		{
			if (!inFrame) 
			{
				inFrame = (b == SOF);
				if (inFrame) 
				{
					FrameBytes.Clear();
					FrameBytes.Add(b);
				}
				return;
			}

			FrameBytes.Add(b);
			if (FrameBytes.Count > 4)
				if (Length+1 == FrameBytes.Count)
					CompleteFrame = true;
		}

		/// <summary>
		/// construct a new, empty, frame
		/// </summary>
		public MPRFrame() {}

		/// <summary>
		/// Construct a new request frame with the given opcode (command) and parameters (parameters).
		/// </summary>
		/// <param name="command">The opcode for the new Request Frame.</param>
		/// <param name="parameters">The parameters for this Frame.</param>
		public MPRFrame(CmdCode command, byteList parameters)
		{
			if (parameters == null) parameters = new byteList();

			// Start payload with frame header (NodeAddress, Length, cmd)
			byteList payload = new byteList(new byte[] {DEF_NODE_ADDRESS, (byte)(parameters.Count + 5), (byte)command} );
			dataBytes = parameters;
			payload.Add(dataBytes);	// Add command data

			FrameBytes.Add(SOF);								// start fram with SOF
			FrameBytes.Add(payload);							// Put payload after SOF
			FrameBytes.Add(CalculateFrameCRC(payload));			// Append CRC
		}

		/// <summary>
		///	The Frame crc calculation uses a table lookup to generate CCITT CRC values.
		///	The CCITT polynomial is: x^16 + x^12 + x^5 + 1
		///	Forward direction table - i.e. msbit first
		///	</summary>
		private static ushort[] crctab = 
			new ushort[] {
							 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
							 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
							 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
							 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
							 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
							 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, 
							 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, 
							 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, 
							 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, 
							 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 
							 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 
							 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 
							 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 
							 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 
							 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, 
							 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, 
							 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, 
							 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, 
							 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 
							 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 
							 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 
							 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 
							 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, 
							 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, 
							 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, 
							 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, 
							 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, 
							 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 
							 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 
							 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 
							 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 
							 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 
						 };

		private const ushort crcSeed = 0xFFFF;

		/// <summary>
		/// Compute the MPR crc for a byteList
		/// </summary>
		/// <param name="buffer">the buffer over which to perform the CRC</param>
		/// <returns>the 2-byte crc</returns>
		public static ushort CalculateFrameCRC(byteList buffer)
		{
			ushort crc = crcSeed;

			if (buffer == null) return 0;
			foreach (byte b in buffer) 
				crc = (ushort)((crc << 8) ^ crctab[(crc >> 8) ^ b]);

			return (ushort)(~crc);
		}

		/// <summary>
		/// Whether or not the CRC of this Frame is valid: {crc == CalculateFrameCRC(Payload)}
		/// </summary>
		public bool CRCValid { get { return (CalculateFrameCRC(Payload) == crc); } }

		private const byte DEF_NODE_ADDRESS = 0;
		private const byte SOF = 0x01;
	}
}