Before you can write CRC calculation procedure you must understand Ensyc Reader to Host and Host to reader protocol (command) format.

Following I have given example(s) of routine. It takes two arguments.

1 An array of bytes on which calculation will be performed

2. Length of byte array which you are actually going to perform CRC operation.

Example: You can pass byte array 20 bytes long and you can pass length 16. In this case last four bytes of an array will not be used for CRC calculatin. It is designed this way so you don’t have to create new byte array to pass it to routine that you have already been working with to construct host to reader command.

C# .Net Example.

Here function returns two byte that you will be appending to host-to-reader command before sending it.

           public byte[] CalcCRCITT(byte[] buf, int wlen)
                {
                UInt16 cnt, crc, data, dbit, i;
                byte[] ret = new byte[2];
                crc = 0xFFFF;
                for(cnt = 0; cnt < wlen + 1; cnt++)
                    {
                    if(cnt == wlen)
                        data = 0;
                    else
                        data = buf[cnt];
 
                    for(i = 0; i < 16; i++)
                        {
                        UInt16 itemp;
                        itemp = (UInt16) (data & 0x8000);
 
                        dbit = 0;
                        if(itemp > 0)
                            dbit = 1;
 
                        UInt16 temp;
                        temp = (UInt16) (crc & 0x8000);
                        if(temp > 0)
                            {
                            crc = (UInt16) (crc << 1);
                            crc = (UInt16) (crc | dbit);
                            data = (UInt16) (data << 1);
                            crc = (UInt16) (crc ^ 0x1021);
                            }
                        else
                            {
                            crc = (UInt16) (crc << 1);
                            crc = (UInt16) (crc | dbit);
                            data = (UInt16) (data << 1);
                            }
                        }
                    }
                ushort mreturn;
                mreturn = (ushort) crc;
 
                ret[1] = (byte)(crc & (UInt16)0x00FF);
                crc = (UInt16)((UInt16) crc >> (UInt16) 8);
                ret[0] = (byte)crc;
                return ret;
                }

Java Example

(Thanks to one of our partner) . This routing hasn’t been tested by Ensyc Technologies.

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package chromogathering.Models;
 
/**
 *
 * @author enyone
 */
public class Crc16
{
 
  private Crc16()
  {
    super();
  }
 
  public static int calcCRC( char[] buf, int wlen )
  {
    int crc = 0xFFFF, data, dbit = 0;
 
    for ( int cnt = 0; cnt < wlen + 1; cnt ++ )
    {
      if ( cnt == wlen )
      {
        data = 0;
      }
      else
      {
        data = buf[cnt];
      }
      for ( int i = 0; i < 16; i ++ )
      {
        if ( (int)(data & 0x8000) > 0 )
        {
          dbit = 1;
        }
        else
        {
          dbit = 0;
        }
 
        if ( (int)(crc & 0x8000) > 0 )
        {
          crc = crc << 1;
          crc = crc | dbit;
          data = data << 1;
          crc = crc ^ 0x1021;
        }
        else
        {
          crc = crc << 1;
          crc = crc | dbit;
          data = data << 1;
        }
      }
    }
 
    return crc;
  }
 
  public static char[] calculateCcittCrc( char[] data, int iStartIndex, int iSize )
  {
    char[] buffer = new char[iSize];
    int count = 0;
 
    for ( int j = 0; j < data.length; j ++ )
    {
      if ( j >= iStartIndex && j < iSize + iStartIndex )
      {
        buffer[count] = data[j];
        count ++;
      }
    }
 
    int crc = calcCRC( buffer, buffer.length );
 
    char[] retVal = new char[2];
 
    retVal[0] = (char)((crc & 0xFF00) >> 8);
    retVal[1] = (char)(crc & 0xFF);
 
    return retVal;
  }
}

C Example

/*********************************************************************/
/* CalcCRC()                                                         */
/*          calc CRC from tag read                                   */
/*********************************************************************/                       
Uint16 CalcCRC(unsigned char *buf,Uint16 wlen) {
Uint16 cnt,crc,data,dbit,i;
 
 crc=0xFFFF; //seed
 for(cnt=0;cnt<wlen+1;cnt++){ //for each 16 bit word
  if(cnt==wlen)
   data=0; //finally shift a word of 0s
  else
   data=buf[cnt];   //get the data word
  for(i=0;i<16;i++){  //for each bit
   dbit=data&0x8000?1:0;
   if(crc&0x8000){  //if bit 15 set
    crc=crc<<1;
    crc=crc|dbit;
    data=data<<1;
    crc=crc^0x1021;
   }
   else{
    crc=crc<<1;
    crc=crc|dbit;
    data=data<<1;
   }
  }
 }
 return crc;
}

VC++ Example

This is complete console application example.

 
// cec_Check.cpp : Defines the entry point for the console application.
//
 
#include "stdafx.h"
/*********************************************************************/
/* Tag_CRC()                                                         */
/*          calc CRC from tag read                                   */
/*********************************************************************/                							
 
__int16 Tag_CRC(unsigned char *buf,__int16 wlen)
{
__int16 cnt,crc,data,dbit,i;
	crc=(__int16)0xFFFF;	//seed
	for(cnt=0;cnt<wlen+1;cnt++){	//for each 16 bit word
		if(cnt==wlen)
			data=0;	//finally shift a word of 0s
		else
			data=buf[cnt];			//get the data word
		for(i=0;i<16;i++){		//for each bit
			dbit=data&0x8000?1:0;
			if(crc&0x8000){		//if bit 15 set
				crc=crc<<1;
				crc=crc|dbit;
				data=data<<1;
				crc=crc^0x1021;
			}
			else{
				crc=crc<<1;
				crc=crc|dbit;
				data=data<<1;
			}
		}
	}
	return crc;
}
 
int main(int argc, char* argv[])
{
	//__int16 jigar;
	__int16 wlen = (__int16) 10;
	__int16 crc;
	//01 FF 58 44 00 02 18 48 01 5E
	unsigned char command[10] ; 
	command[0] = (unsigned char) 0x10;
	command[1] = (unsigned char) 0xFF;
	command[2] = (unsigned char) 0x58;
	command[3] = (unsigned char) 0x44;
	command[4] = (unsigned char) 0x00;
	command[5] = (unsigned char) 0x02;
	command[6] = (unsigned char) 0x18;
	command[7] = (unsigned char) 0x48;
	command[8] = (unsigned char) 0x01;
	command[9] = (unsigned char) 0x5D;
	crc = Tag_CRC(command,wlen);
	printf("%d ", crc );
	getchar();
	return 0;
}

1.What is tag memory?

The Gen2 tag memory is logically separated in four memory banks.

2.How can we Lock it?

Now there are two methods that can be used to write tag, OPEN state and SECURED state. If the tag’s access password is zero, the tag never enters the OPEN state, but goes directly to the SECURED state. If tag has Access Password it will goes to OPEN state unless Access Password is provided. This will help you read tag but you can’t write tag in this mode.

There are four possible locks for each memory bank. But mostly we are interested here in EPC memory bank for tag value.

	Bank is writeable from either the OPEN or SECURED state.
	Bank is permanently writable from either the OPEN or SECURED state.
	Bank is writable from the SECURED state but not from the OPEN state.
	Bank is not writable from any state

We are not interested in first two kind of lock as it doesn’t protect tag memory from being written. If are interested writing tag just once and lock it forever 4^th solution is right for you. It can be useful in some cases like employee base with fixed id number, file number. What if you want to use tag over and over again but still want it write protected with password, 3^rd case is right for you. We will discuss the 3rd case here.

3.What are the steps?

There are two cases here, tag has some Access Password value set or it is all zeroes.

If tag doesn’t has Access Password, you can create one (Coming Soon).

If tag already has Access Password then you can

1. Lock tag if it not already locked. You can do this if the tag is unlocked or change lock type if it not permanently locked. You can also unlock tag. Unlock refers to first to lock types which just opens up tag for writing.

 //We need to provide 4 bytes long Acces Password to lock the tag.
byte[] AccessPassword = new byte [] {0x00,0x00,0x03,0x04};
Program._Reader.Gen2LockTagMemory(10, 10, AccessPassword, EReader.ProtectTagMemory.LockTypes.PASS_LOCK);

4. What about Access Password?

As you are protecting tag value you can also protect Access Password in the same manor. Here also we have four possible lock for Access Password and Kill Password protection.

	Password is readable and writeable from either OPEN state or the SECURE state.
	Password is permanently readable and writeable from either the OPEN or the SECURE state.
	Password is writeable from the SECURED state but not from the OPEN state.
	Password is not readable or writable from any state.

Note: It is enought if you just lock EPC memory area of tag for general protection of tag. It will prevent tag value to be overwritten by any mistake. If you are locking tag value permenently, there is no way it can be reversed so be more causious.  If you are locking Acess Password make sure you have store it safe somewhere else because there is no way to recover either once you lock it permanently.

Sample code for the illustraion of this article coming soon…

If you still have any question or query feel free to contact us.

FOR IMMEDIATE RELEASE:

Ensyc Technologies
Reno, NV
775-826-7343
Ensyc Technologies is pleased to announce the issuance of a Patent on its RF-EZ RFID dispense product. This product was designed to fill the upcoming need for a home office web based appliance to manage the dispense and encoding of RFID tags. “Future express shipping labels will need to be integrated with RFID tags in order to facilitate more efficient operations for the carriers. This product allows the carrier to integrate the production of a shipping label with encoding of an RFID tag through the web based applications they currently use”; says Steve Jessup, President of Ensyc Technologies.

This product holds a roll of labels with embedded RFID tags and dispenses them over an RFID Encoder to allow an application to generate an RFID tag value that will be associated with a shipping label that can be produced on the user’s standard laser or inkjet printer. Both actions are controlled by the same application and their combined success is needed to produce the appropriate shipping label.

The product could also be used with other applications that require the production of a document and an associated RFID tag. As an example, medical records and legal files.

For more information on products available from Ensyc Technologies, please visit our web site at www.ensyc.com

Ensyc Technologies manufactures the lowest cost, highest performance short range UHF reader/writer available today.

FOR IMMEDIATE RELEASE:

Ensyc Technologies
Reno, NV
775-826-7343
Ensyc Technologies is pleased to announce the issuance of a Patent on its UHF RFID reader/writer. “Our Low Cost, Short Range UHF RFID reader/writer is a very unique product”, said Steve Jessup, President and CEO of Ensyc Technologies. “It was designed specifically for the embedded market (RFID Thermal Printers) and has proven itself to be the fastest and lowest cost UHF encoder available today.”

Designed to accommodate the compliance demands of the supply chain, it has unique characteristics that allow it to outperform readers designed for long range multi tag environments. “Using our reader module would cut the cost of RFID implementation in Thermal Printers by over fifty percent”, said Mr. Jessup.

Additionally, the unit was designed to work with a far field antenna, even in confined environments. “A known problem can occur when using a near field antenna to couple with tags, as they can communicate with a defective antenna that will not be seen by a standard far field system.”, said Mr. Jessup.

While the product was designed to be embedded, it has proven to have a much broader application base in the UHF RFID arena. File management, access control, Point-of-Sale, Payroll, Security and Library applications are just a few of the many uses that our readers are being called upon to fulfill. The Block, the Brick and the RF-EZ are just a few of the products currently available, or in development, that use the Ensyc reader modules. Several printer and print & apply companies are now using the RF1200 reader with excellent results and very low cost factors.

For more information on products available from Ensyc Technologies, please visit our web site at www.ensyc.com

Ensyc Technologies manufactures the lowest cost, highest performance short range UHF reader/writer available today.

FOR IMMEDIATE RELEASE:

Ensyc Technologies
Reno, NV
775-826-7343
Ensyc Technologies is pleased to announce the release of its new, more powerful, UHF reader/writer module the RF2400. “The RF2400 replaces our very successful RF1200 product”, said Steven Jessup, President and CEO of Ensyc Technologies, “Incorporating new technical features built on its patented RF1200 product, the RF2400 has a greater read range and on-board memory to allow for autonomous, battery powered data collection applications.”

Using new, patent pending techniques, the RF2400 has increased speed, range and reliability over its predecessor the RF1200. Additionally, support for a battery (optional) and on-board memory allow for independent operation for remote data collection. The module is available with RS232 or TTL communications and has an optional USB interface available.

“The RF1200 was already one of the most intelligent and capable UHF readers on the market”, says Mr. Jessup, “and these new features on the RF2400 only serve to extend the uses for this product.”

While designed primarily for embedded applications, specifically Thermal Printers, the Ensyc products have found acceptance in a variety of RFID applications including file management, point of sale, access control, security and library management.

For more information on products available from Ensyc Technologies, please visit our web site at www.ensyc.com.

Ensyc Technologies manufactures the lowest cost, highest performance short range UHF reader/writer available today.