All Embedded

EG3

EE Compendium

Arm

Atmel

Microchip

Electronic Engineer

Electronic Consultant

Embedded Programmer

The driver requries approximately 40 bytes of static RAM memory space.  It requires only a small amount of temporary variable storage space from the stack.

In the Microchip PIC18 sample project using an 8 bit microcontroller running with a 125nS instruction clock (8MHz crystal with 4 x PLL) the rfid_sampling_rising_edge() function takes a maximum of 95uS to complete (typcially significantly less – the most time is taken after parity bits are receveid).  This is with no C18 compiler optimisations enabled.

The above should allow you to decide on a suitable interrupt arrangement for your microcontoller based on the other demands of your applicaiton.  Remember that the rising edge interrupt is only active when reading a RFID tag.  When the driver is idle the interrupt is disabled.

When your applicaiton calls the rfid_read_tag() function the driver then enables the HTRC110, carries out several configuration functions and RF value setting operations before placing the HTRC110 in read mode.  In this mode the Dout pin of the HTRC110 simply passes the received modulated data from the RFID tag, or if no tag is present it will contain trash data.  The 64bits of data the RFID tag will be continuously transmitting in a cycle containing 9 header bits, 40 data bits and 14 parity bits.  The header bits allow the start of the data sequence to be identified and the 14 parity check bits provide sufficient error detection to ensure that only a valid RFID tag will be read.  The EM4102 datasheet provides a lot of detail about the data bits and the possible modulation methods.

Once in read mode the HTRC110 outputs a 125kHz sine wave. The tag (if present) will interfear with the RF sine wave signal in order to pass its data stream back which the HTRC110 detects for us. When reading is active the Dout pin of the HTRC110 contains the raw data output of the tag after being filtered into a digital signal by the HTRC110.

Although the tag data length is 64 bits the driver needs to receive an initial 22 bits to determin the bit rate and then between 64 to 127 bits need to be received before we have a complete sequence.

Therefore a read can take 149 bits x 512uS maximum bit rate = 76mS.

Tags will often be set to use the slowest 512uS bit rate as slow transitions on the air interface are easier to detect, which means you get additional range and more reliable communications.

The EM4102 protocol permits tags to respond with Manchester, BiPhase or PSK (Phase Shift Keying)  modulation.  Although any of the 3 methods can be used tags basically always use Manchester encoding as there are many RFID readers out there that only support manchaester encoding.  This driver supports Manchester and BiPhase encoding, as BiPhase is very similar to Manchester and there is minimal code footprint required to also support it.  Although supporting PSK is not an particuarly complex task, it does requrie specific microcontroller hardware to be done efficiently and would cause unessary complexity so as PSK is not used in practice this driver does not support it.

For Manchester or BiPhase modulation the tag will be responding with 1 bit every 64, 32 or 16 periods of the carrier frequency, and will change state once or twice during this (the tag is allowed to use any of these three as its data rate). Using a clever detection method the driver only needs to detect each rising edge to determine the preceeding bit states, reducing the interrupt burden on the main application. Also only detecting each rising edge removes issues of dealing with non perfect high and low widths within each cycle – being radio they are often not perfectly 50/50, but the overall bit frequency will be relatively accurate.

So for either of these modulations the bit rate will be approximately 128uS, 256uS or 512uS. If the tag was using PSK modulation it would be changing state every carrier frequency period (every 8uS)

Once the bit rate has been determined by the driver it calculates the 125% and 175% bit times which it will then use to decode the data stream.

The driver now decodes the receied data bits on the fly as they are received.  This is a much more efficient and minimal memory requriement approach rather than storing a large chunk of data and decoding it later.

To find the header the driver looks for the bit sequence 0111111111 which is the stop bit followed by header. This sequence cannot occur anywhere else in the tags 64 bit stream.

From the header bitstream the driver is able to determin if Manchester of BiPhase modulation is being used by the RFID tag.  The driver then decodes the remaining bits of the 64 bit sequence, checking for a parity error as each parity bit is received.

If all of the parity checks pass and the final stop bit is received the RFID read is a sucess and a valid tag has been detected.  The driver stores the 10 character ASCII hex tag ID ready for the main application to read and switches the HTRC110 back into low power mode.  When a tag is present and in range there is typcially no need for a retry – the read sequence will typically work first time.

However the driver will retry for up to 150mS in case it helps where the signal is week. As this driver checks for parity errors as nibbles are received (rather than at the end) failures can occur early on in the bit sequence, so doing this will often mean the driver is ready to try again at the start of the very next sequence from the tag.

If no valid tag bitstream is detected the driver switches the HTRC110 back into low power mode and declares the read a failure.

• Are the communicaitons between the HTRC110 and your microcontroller working correctly – does the HTRC110 reply?  Use the RFID_SPI_SAMPLE_CS_PIN and a logic analyser to capture these if necessary.
• Is the time value being passed to the rfid_sampling_rising_edge() function correct – check with a scope.
• In the function rfid_sampling_rising_edge() breakpoint at the end of the section “//—– CALCULATE THE CYCLE TIMES —–”.  Is the rfid_1us_bit_rate correct?  If you use a logic analyser to capture Dout from the HTRC110 during tag reading you will be able to determin the bit rate by looking for the shortest low high pulse sequence (high edge to high edge) – does rfid_1us_bit_rate match?

The HTRC110 is a great RFID reader IC and it takes care of all aspects of the radio frequency transmittion and reception.  It incorporates features to remove tuning and calibration requirements which can be a clasic pain of RFID reader deisgn.  The communication interface to the microcontroller is similar to SPI.  However a special start bit sequence is used and there is no chip select pin making it not directly compatible with SPI.  The driver incudes an option to allow a spare microcontroller pin to be used as a dummy chip select pin, allowing you to use a logic analyser to capture the communications between the HTRC110 and your microcontroller during development if you wish – see the rfid.h file for details of enabling this.

Reading Tags

The HTRC will take care of all aspects of the radio frequency side of things for you, but its output when reading a tag is the raw modulated data output from the tag.  This 64bit continuous looping data stream needs to be decoded by your microcontoller to determin if the data is from a valid tag or if it is just RF noise (if no tag is present the datastream will contain junk data).  Once the HTRC110 has been put in read tag mode in will pass the data stream until the microcontroller stops it.  It is during this phase that the HTRC uses the most power.

Original Release

void rfid_process (void)

This function should be called regularly as part of your applications main loop.

void rfid_read_tag (void)

Call this function to start the read tag process

BYTE rfid_get_read_tag_result (void)

Call this function to check for the end of the read tag process.  It returns 0 if still reading, 1 if completed. Bit 7 will be set if the read failed.

After a sucessful read the ASCII tag ID will be in rfid_data_nibbles[0] | rfid_data_nibbles[9]

void rfid_sampling_rising_edge (WORD us_since_last_rising_edge)

Call with us_since_last_rising_edge = The time in uS since the last edge interrupt. You application interrupt hander must create this value from an available microcontroller timer. The maximum time between interrupts will be approximately 1024uS, so your timer calculation only needs to deal with time values of up to say 1280uS (to give a reasonable margin of worst case tollerance).

Call with the timer value captured as close as possible to the rising edge occuring (reduce latency as much as possible).

This fucntion will ignore the value for the first 2 calls allowing for initial timer error.

void rfid_force_initialise (void)

In typical use this function is not requried as the driver will automatically initialise the HTRC110 IC on powerup. However if you are using this driver with multiple HTRC110 devices (for instance by switching the SCLK, DIN and DOUT lines by using one or more 74HC4053 IC’s) then this function can be called during your applications initialisation after selecting each HTRC110.  To read each HTRC110 call rfid_read_tag() and wait for rfid_get_read_tag_result() to return a completed result before switching to the next HTRC.