Simultaneous RFID Tag Reader Hookup Guide

Contributors: Nate
Favorited Favorite 7


The SparkFun Simultaneous RFID Tag Reader (SRTR for short) has numerous features that make it a huge leap forward over other RFID readers.

SparkFun Simultaneous RFID Reader - M6E Nano


The greatest feature is that the SRTR is able to read multiple tags at the same time. Additionally the read distance of tags is greatly increased (up to 16 feet!) from other readers. Did we mention you can write your own data to the tags? Oh yea, you can do that too.

Suggested Materials

The SRTR was designed to work either with a USB to Serial connection to a computer or as a shield to an Arduino-compatible board. If you’re just getting started we recommend you start with the serial connection to a computer so that you can use the Universal Reader Assistant software to experiment quickly with different tags and read distances. Then move to a microcontroller or single board computer.

USB to Serial Connection

For a basic set-up using the SRTR with a USB-to-Serial connection, we recommend the following products.

USB micro-B Cable - 6 Foot

Break Away Male Headers - Right Angle

SparkFun Serial Basic Breakout - CH340G


Arduino Shield Connection

If you’re using the SRTR as a shield, we recommend the following materials.

SparkFun RedBoard - Programmed with Arduino

Arduino Stackable Header Kit - R3

Wall Adapter Power Supply - 5V DC 2A (Barrel Jack)


Any microcontroller or single board computer capable of 115200bps will work (however the module can be configured to 9600bps). The SparkFun RedBoard or Arduino Uno are popular options for this role, but just about any microcontroller development board should work. (The firmware examples use an Arduino library, if that serves as any extra motivation to use an Arduino.) You will want an external power supply to run the module at full power. Please see the Power Supply Considerations section for more information.

Additional Materials

To follow along with the examples in this tutorial, you will also want access to some UHF passive RFID tags, and optionally, an antenna for extended range, and an attachment cable.

UHF RFID Antenna (TNC)

UHF RFID Tag - Adhesive (Set of 5)

UHF RFID Tag (Set of 5)



Suggested Reading

If you aren’t familiar with the following concepts, we recommend checking out these tutorials before continuing.

Hardware Overview

The main component of the SRTR is the M6E-NANO module from ThingMagic. ThingMagic has been in the multi-tag RFID business for years. Their newly release M6E-NANO module has reduced the cost of entry while maintaining many of the key features of multi-tag reading.

Module in focus

The M6E-NANO works with common, low cost, passive, Gen2 UHF tags available from a variety of online vendors in a variety of shapes and sizes. We offer two tags, with and without adhesive backing. Both have 64 bytes of user writable memory.

This module runs at 5V and pulls its power from the 5V lines on the breakout board.

Serial Interface

The M6E-NANO module is controlled via serial. There are two serial connections available: via a 6-pin FTDI compatible connection and via the TX/RX pins on the Arduino shield.

Serial connections in focus

Serial Selection Switch

A switch is provided to allow the user to select between Hardware Serial (HW-UART) and Software serial (SW-UART) pins on the Arduino-compatible footprint. Set this switch to SW-UART for all the example Arduino sketches provided below. If you are using an external USB to Serial connection this switch has no effect.

Serial Select switch

Switch allows user to select between hardware and software serial

Enable and GPIOs

The M6E uses an internal DC to DC converter to provide itself with power. When the EN (enable) pin is pulled low the DC/DC converter is turned off and the module does a hard reset. EN can be left unconnected for normal operation.

Enable and GPIOs on the SparkFun RFID shield

Bank of Enable and GPIO pins

The NANO uses a SAMD21 as its main processor. The LV2, LV3, and LV4 pins are connected to the GPIOs on the SAMD21. They can be set high/low but these features are not yet supported in software.

Note: The EN and GPIO1 pins are 5V tolerant. The LV2, LV3, and LV4 pins are 3.3V only.


A buzzer is connected to pins 9 and 10 and can be PWM controlled to produce a tone.

Buzzer connections in focus

The most common use is to beep when a new tag is detected. This makes range testing much easier as you can bring the tag into the field until you hear a beep.


A jumper on the rear of the board labeled JP1 is closed by default allowing the board to be powered via the USB to Serial converter.

Rear JP1 Jumper

JP1 Jumper

By default the JP1 Jumper is closed allowing the USB to Serial converter provide power to the SRTR. Cut this jumper if you are powering the board with a LiPo battery or other external power supply. This will isolate the USB to Serial converter for communication only.

Ground Plane Heatsink

The SRTR has a large ground plane heatsink on the bottom of the shield.


The exposed copper pour along with two mounting holes allow the connection to a heatsink such as a chassis or block of metal. Your board should have also shipped with a piece of Thermal Gap Filler. Please check out the Thermal Considerations section for more information on this.


The Nano M6E is a powerful transmitter capable of outputting up to 27dBm! That’s a lot.

The SRTR comes with an on-board PCB trace antenna, and a u.FL connector for an external antenna. An ANT Select solder jumper allows users to select between the two options. Check the Using an External Antenna section for more information on this.


In this jumper configuration the PCB antenna is selected

The PCB antenna is an excellent way to begin to experiment with UHF RFID. You’ll be able to read and write tags that are within 1 to 2 feet of the PCB. If you would prefer to use an external antenna, you can find more information in the Using an External Antenna section.

Warning: Ensure that personnel do not stand in the radiation beam of the antenna unless they are more than 21cm away from the face of the antenna (to adhere to FCC limits for long-term exposure). See Datasheet for more information.

Hardware Hookup

There are two main options for hooking up this board. Depending on how you plan to communicate with the board will change which method is recommended for you.

We recommend reviewing the through-hole soldering tutorial and how to work with wire if you are not familiar with basic soldering techniques.

Communicating via USB UART Serial

To communicate with an FTDI Breakout, Serial Basic, or other similar USB UART boards, you will need to solder a 6-pin right angle header to the Serial port section of the SRTR.

Attaching the 6-pin header

Plug in your serial breakout board via USB to your computer, and hook it up to the right angle headers that you just soldered to your SRTR.

Communicating via Arduino-Compatible Board

To use the SRTR as an Arduino shield, you will need solder stackable headers onto the shield. Check out our tutorial on soldering stackable headers if you are not sure how to do this.

We’ve used the SRTR with the RedBoard and other Uno compatible boards. Unfortunately the Leonardo and Mega don’t support Softwareserial RX on pin 2 so you’ll need to wire from pin 2 on the shield to pin D11. Additional pins will work for software RX but see the Softwareserial page for more information.

RFID Arduino Shield with stackable headers

Shield with stackable headers installed.

Note: The ground plane heat sink may connect with the Arduino ISP headers causing a short. We recommend adding the piece of gray, non-conductive thermal pap filler that shipped with your shield to prevent a short.

Thermal Gap Filler

Next, install the shield onto the Arduino of your choice. We use the SparkFun RedBoard.

Isolating the ground plane

Thermal Gap Filler isolating the thermal pour from the RedBoard ICSP pins

Using an External Antenna

Swapping from the PCB antenna to an external antenna can help with the range of your SRTR, but there are a few things to keep in mind before making that leap.

FCC Regulations

From page 42 of the Nano Design Guide:

No additional transmitter-compliance testing is required if the module is operated with the same type of antenna as listed in the FCC filing as long as it has equal or lower gain than the antenna listed. Equivalent antennas must be of the same general type (e.g. dipole, circularly polarized patch, etc.), must be of equal or less gain than an antenna previously authorized under the same FCC ID, and must have similar in band and out of band characteristics (consult specification sheet for cut-off frequencies).

The PCB trace antenna is a patch antenna with much lower gain than the list of approved antennas, therefore, the SRTR evaluation board as-is can be used in the field without additional FCC testing.

The u.FL connector is an easy way to connect higher gain directional antennas. However, there are stipulations as to what external antennas can be used and additional FCC certifications may be required.

Note: The onboard PCB antenna complies with the FCC regulation.

Below is a list of antennas that ThingMagic has tested and gotten approved by the FCC. You may use a different antenna from the ones in the list but it must be of equal or less gain than an antenna previously authorized under the same FCC ID, and must have similar in band and out of band characteristics (consult specification sheet for cut-off frequencies) in order to use it in a product without additional testing.

Table of antennas

List of approved antennas

Attaching the External Antenna

If you want to switch from the onboard antenna, you will need to change the antenna jumpers around to enable the u.FL connector.

Note: You do not need an external antenna for most examples in this hookup guide; however, you will want to use an external antenna for Example 10

Using some solder wick, clear the solder jumper to the trace antenna and close the solder jumper to the u.FL connector by adding a blob of solder.

Antenna jumper set to external u.FL connector

ANT Select modified to connect the Nano module to the u.FL connector

Next, attach the u.FL to the RP-SMA connector cable. Because this connector is fragile we recommend either taping or hot gluing the sheath of the cable to the PCB. This will help prevent damage to the u.FL connector in case the cable gets pulled on.

Cable taped to board

To get the best range we recommend attaching an external high-gain antenna to a tri-pod of some sort. If you only have a desk, that’s ok too.

RFID Antenna attached to tripod

We used the included hardware with the antenna to attach it to a leg of the tripod.

Antenna attached to tripod

Now connect the RP-SMA to RP-TNC cable. And finally connect the RP-TNC to the external antenna. You can use a different UHF RFID antenna but you will need to have the correct connectors and cables to go from the u.FL connector on the PCB to the connector on your specific antenna.

alt text

u.FL connector to RP-SMA to RP-TNC

Don't Forget! Ensure that personnel do not stand in the radiation beam of the antenna unless they are more than 21cm away from the face of the antenna (to adhere to FCC limits for long-term exposure). See Datasheet for more information.

Power Supply Considerations

The SRTR can be powered from the target board, the USB connection, or an external power supply.

Don't Forget! Unless you are using USB power to power the SRTR, don't forget to cut JP1 on the bottom of the board if you are communicating with the board with a USB to Serial connection.

USB Power (Good)

Standard USB ports will source up to 500mA. Because the Nano module can pull up to 720mA when powered from 5V the module will brown out and reset when operating at full read power. However, if read power is kept below 5dBm the SRTR can be evaluated using a simple USB-to-serial connection such as the FTDI Basic or Serial Basic.

USB to Serial attached to RFID shield

USB power only. Limited to 5dBm read power.

External/Battery Power (Better)

There is a footprint available to install a 2mm JST connector or a 3.5mm screw terminal. LiPos work well to power the module, however, if using a LiPo battery (3.7V nominal voltage) you can expect to use more than 1000mA during full read power. Pick your battery size accordingly. Alternatively, the 3.5mm screw terminal may be installed to connect to external power such as a bench power supply.

Battery attached

LiPo Battery powering the RFID shield

Target Power (Best)

Powering the SRTR over the 5V pin from an Arduino works well if the Arduino has an external power supply such as a 5V wall adapter. If the Arduino is powered only by USB the module will brown out under full read power. It’s important to note that the shield gets its power from the 5V pin which means it’s drawing power from the onboard regulator of whatever platform you are using. If you provide your RedBoard with 9V and draw 1A through the 5V regulator it will get red-hot. Use a 5V power adapter to reduce the thermal strain on your regulator.

External power connected to RedBoard

RedBoard with 5V adapter attached

Thermal Considerations

At full read power over extended periods of time the module can reach temperatures greater than 85C (185F). This is extremely toasty. The module will automatically throttle itself to prevent permanent damage from heat. The SparkFun Simultaneous RFID Tag Reader shield provides enough ground plane heatsinking to allow the module to operate at full read power for tens of minutes. If you plan to operate the module at full power for extended periods of time we recommend attaching a heatsink.

You can get the 1:1 dimensional drawing of the shield here. The dimensions of the exposed thermal and mounting holes are shown.

Dimensional Drawing showing the location of the exposed thermal pad

Dimensional Drawing of the RFID Shield showing the mounting holes and exposed thermal pad

In most prototyping applications heatsinking won’t be required. However, if you have heat sensitive items near the module (such as temperature or humidity sensors) they may be influenced by the module. If you are planning to install the module for long term operation we recommend attaching a heatsink with thermal compound and 4-40 screws and nuts. Alternatively, you may install the Thermal Gap Filler that was shipped with your shield between the SRTR and the heatsink.

The module also supports changing read duty cycle to reduce the heat dissipation as well. Check out the M6E-NANO datasheet for more information.

Software Options

There are three ways of controlling the SRTR:

Universal Reader Assistant

  • Arduino sketches to access the basic read/write features of the board. This is a complex device so we’ve included many example sketches to get you up and running with the main features. You’ll get the example sketches when you download and install the library.

Arduino software sketch

  • Mercury API is ThingMagic’s extensive software libraries in C, Java, and .NET. This enables BeagleBones, Raspberry Pi’s, and other single board computers to get access to the full suite of features. The use of Mercury API is beyond the scope of this tutorial.

API source code

Using the Universal Reader Assistant

If you’re a Windows user the Universal Reader Assistant is a great way to get up and playing with the full capabilities of the M6E-NANO. The downside is that it’s only currently available for Windows.

Start by downloading the Universal Reader Assistant (URA). 32-bit and 64-bit versions are available.

Universal Reader Assistant Download

Once downloaded and installed, hover over the right side of the window. The Setting/Status control panel will open up. Click on the thumbtack icon to keep it open.

Opening communications tab in URA

Expand the Connect menu and select Serial Reader and drop down the menu to select your COM port. Click Connect. The module will be pinged over the serial connection to verify its existence.

Select the com port

Next, select your Region. Since we are in North America, we’ve selected NA2.

Connecting to Serial Com Port

Note: The ‘Transport Logging’ checkbox is very handy. Select this box and all the serial communication will be recorded to a log file. These HEX bytes can be deciphered and recreated using an Arduino or other microcontroller if you need a particular capability or feature that is not supported in the SparkFun Simultaneous RFID Reader Arduino library.

Next open the Read/Write Options and click on 1 under Antennas.

Select the Antenna

Finally, open the Reader Power Settings tab and select your Read Power. Tune this setting down to 5dBm. If you want to power the board from USB then use a power setting below 5dBm. 27dBm is ok to use only if you have external power (more than one USB port can provide). See the Power Supply Considerations section for more information.

Power Setting Menu

Now we’re ready to read! Click on the Read button at the top. Bring some RFID tags near the reader and you’ll see them appear.

Continuously reading tags

There are a ton of features to the Nano from ThingMagic. Poke around the Universal Reader Assistant to learn more. Write EPC and User Memory are two of the most commonly used tabs.

Thermal Throttling: If you see this window pop up it means the module is reporting a temperature-limit fault condition.

Thermal error window

The module has an internal temperature sensor and will protect itself from permanent damage. You’ll need to lower your read power or add heatsinking. See the Thermal Considerations section for more information.

Using the Arduino Library

We’ve written an Arduino library for the M6E-NANO RFID module which takes care of all of the serial communication, byte manipulations, and CRC verifications.

Note: This example assumes you are using the latest version of the Arduino IDE on your desktop. If this is your first time using Arduino, please review our tutorial on installing the Arduino IDE.

If you have not previously installed an Arduino library, please check out our installation guide.

The easiest way to install the library is through the Arduino Library manager. You can also manually install the library with the following download from GitHub.

Download the SparkFun Simultaneous RFID Tag Reader Arduino Library

Once you’ve installed the library, you should see the Example sketches by navigating to File > Examples > SparkFun Simultaneous RFID Tag Reader Library > Examples.

M6E NANO RFID Example Menu

Example 1 - Constant Read

Make sure you have set up your SRTR according to the directions in the Hardware Hookup section, and have installed your shield on an Arduino-compatible board.

Be sure the serial selection switch is set to Software. This connects pins 2/3 of the Arduino (for softSerial) to the serial port on the Nano, and allows the shield to work with the following Arduino examples.

Serial selection switch

UART Selection Switch Set to SW-UART.

Once you’ve got the shield attached and library installed, open the Example1 Constant Read sketch. You can find it under

File > Examples > SparkFun Simultaneous RFID Tag Reader Library > Examples

Then load it onto your RedBoard. Open your favorite Serial Terminal to see the printed values. The first example demonstrates how to scan constantly and report any tags in the vicinity.

Screen shot of reading EPC and RFID tags

This example outputs the EPC from any tag in the vicinity. Note there are two different tags shown in this list.

Let’s look at the setup code:

if (setupNano(38400) == false) //Configure nano to run at 38400bps
  Serial.println(F("Module failed to respond. Please check wiring."));
  while (1); //Freeze!

nano.setRegion(REGION_NORTHAMERICA); //Set to North America

nano.setReadPower(1500); //15.00 dBm.
//Max Read TX Power is 27.00 dBm and may cause temperature-limit throttling

nano.startReading(); //Begin scanning for tags


The Nano communicates over serial at 115200bps at power up. Because we are using software serial on pins 2/3 on the RedBoard we need to slow communication down to 38400bps. setupNano() is a local function that will tell the Nano to go to 38400bps and then verify that communication is open.

nano.setRegion(REGION_NORTHAMERICA); //Set to North America

Because different countries have different regulations for UHF RFID .setRegion() is used to configure the frequencies to operate within. Allowable regions are:


Select the region closest to you or establish which regulations within your country match one of the available regions.

nano.setReadPower(500); //5.00 dBm. Higher values may caues USB port to brown out
//Max Read TX Power is 27.00 dBm and may cause temperature-limit throttling

The module is quite powerful and is capable of outputting 27dBm. By default we .setReadPower() to 5dBm so that the examples can be operated from a USB port without extra power. If you have a good power supply such as a LiPo battery or 2 amp wall supply you can increase the read power. See Power Supply Considerations and Thermal Considerations for more information about pushing the envelope.

nano.startReading(); //Begin scanning for tags

The .startReading() function tells the module to constantly scan for new tags and output any tag detected. Once a tag is detected the various bits of tag information (EPC, RSSI, etc) is parsed out of the response and printed.

Why am I getting "Module failed to respond"? Do you have the switch in the SW position? Are you using a Leonardo or Mega? Unfortunately the Leonardo and Mega don't support software serial RX on pin 2 so you'll need to wire from pin 2 on the shield to pin D11. Additional pins will work for software RX but see the SoftwareSerial page for more information.

Example 2 - Read EPC

While a constant read is fun and interactive, it can be an overwhelming amount of data for some projects. The 2nd example shows how to do a single shot read.

If you are unfamiliar with how RFID tag memories work, please review our tutorial here.

File > Examples > SparkFun Simultaneous RFID Tag Reader Library > Examples

Open Example 2 from the examples menu. Then load it onto your RedBoard or Uno.

Reading an EPC

Tag EPC LULZ detected!

.readTagEPC() is the main function call of this example. Pass it an array of bytes (in almost all cases EPCs are 12 bytes), the size of the array (12), and an amount of time to scan before giving up (500ms is default). The function will return with RESPONSE_SUCCESS if a tag is detected and the EPC will be stored in the array you gave it.

responseType = nano.readTagEPC(myEPC, myEPClength, 500); //Scan for a new tag up to 500ms

The buzzer connected to pins 9 and 10

The buzzer is connected to pins 9 and 10

//Beep! Piano keys to frequencies:
tone(BUZZER1, 2093, 150); //C
tone(BUZZER1, 2349, 150); //D
tone(BUZZER1, 2637, 150); //E

We’ve included a buzzer on the shield to allow feedback to the user. In this example we play a simple three note melody to indicate a tag has been detected.

Example 3 - Write EPC

It’s time to do what used to be impossible: Write to a tag!

Load Example 3 to your RedBoard, and open up your serial monitor.

alt text

This example shows how to write your own EPC to a tag.

char stringEPC[] = "Hello!"; //You can only write even number of bytes
byte responseType = nano.writeTagEPC(stringEPC, sizeof(stringEPC) - 1); //The -1 shaves off the \0 found at the end of string

Remember, you cannot change the TID of a tag (that’s its truly unique tag ID), but changing the EPC is a great way to keep track of which tag is which. Setting EPCs to WRENCH or PILL#317 make it easier to visually identify in code which tag you are looking for and need to respond to.

nano.setWritePower(500); //5.00 dBm. Higher values may cause USB port to brown out
//Max Write TX Power is 27.00 dBm and may cause temperature-limit throttling

This example introduces a new function .setWritePower(). Similar to setReadPower, this sets the power level when writing to a tag.

If you are using an external power supply and need to write to a tag feel free to boost this value to 20 or even 27dBm. Because you will rarely be writing to a tag the module shouldn’t reach temperature throttling.

Example 4 - Read User Data

Example 4 shows how to detect and read the available user memory.

Reading User Data from a Gen2 UHF RFID tag

Note that not all UHF RFID tags have user memory, and therefore may not be configurable.

Example 5 - Write User Data

The User memory area is a fun place to play. A given UHF tag can have 0 to 64 bytes of editable User memory. Example 5 shows how to edit the User Data.

alt text

char testData[] = "ACBD"; //Must be even number of bytes. "Hello" is recorded as "Hell".
byte responseType = nano.writeUserData(testData, sizeof(testData) - 1); //The -1 shaves off the \0 found at the end of string

Give .writeUserData() an array of characters and it will be recorded to the first tag detected. A few bytes of editable memory may not sound like a lot be remember these are passive tags - no batteries required! You can query a tag for the user’s dietary restrictions. Or you could adjust the lighting depending on who walked in the room. Or you could set the time at which a medication must be taken. Perhaps a prosthetic leg goes into a more aggressive mode when basketball shorts are worn. The applications get far reaching.

Examples 6, 7, 8 - Passwords

The Example6-Read Passwords example will display the Access and Kill passwords of a given tag. The Access password allows a user to lock a tag, preventing modification of various parts of the memory (EPC, User, etc). The Kill password is needed to disable a tag. Both passwords are 0x00000000 by default.

Reading the Access and Kill Passwords on Gen2 RFID

Passwords are 0x00000000 by default

Example7-Write Passwords will show you how to write new passwords for the Access and Kill portions of memory.

Writing new passwords to RFID tag

New passwords have been written!

To verify these new passwords have been written load Example6 again.

alt text

The new passwords are correctly recorded

It may seem odd that you can view the passwords. The Gen2 protocol has quite a few methods to lock out various portions of the memory preventing them from being read. Once the Access password is set the ability to read passwords, read user memory, and read portions of the EPC can all be controlled; this is called locking. Currently, locking is not supported in the Arduino library but it is available in the URA and in the Mercury API.

The final Example8-Kill Tag is the really fun one. It’s pretty rare that you’ll need to kill a tag but we find the concept fascinating and wanted to build in support for it.

Note: Killing a tag blows an internal fuse to the IC and makes the tag irreversibly dead.

It is very good to see that the protocol has the kill feature. Killing a tag makes sense after an item has been purchased (gallon of milk) or a process has been completed (dry cleaning has been picked up). By limiting the life-span of a tag you can help protect end user privacy and tracking.

The Gen2 protocol is well written and prevents a user from walking into a Wal-Mart and blasting away all the tags that haven’t been configured. The default Kill password is all 0s but any tag will ignore the kill command with the password set to 0s. Therefore, you must first write a non-zero kill password (using Example7) then you must issue the kill command using the new password.

Example of killing an RFID tag

Tag is now D E D, dead.

If you’re very paranoid about someone else using an UHF RFID reader/writer to reconfigure your tags consider writing new Access and Kill passwords to your tags then use the Universal Reader Assistant to lock the tags.

Example 9 - Read TID

TIDs are the truly unique IDs assigned to each tag (and are not editable). They are 20 bytes long so they’re a bit unwieldy but if you need them Example 9 will show you how.

Reading RFID TID example

nano.enableDebugging(); //Turns on commands sent to and heard from RFID module

This example includes a new function called .enableDebugging(). This displays the commands sent to and responses from the RFID module. The counter function is .disableDebugging(). It’s often helpful to see what commands are being sent to the module. Debugging also exposes how the module responded: Did it time out? Did it return an unknown response?

You can pass a port to .enableDebugging(). For example, nano.enableDebugging(Serial1); will enable and output debug messages to port Serial1. If you leave it blank debug messages will be piped to Serial by default.

When experimenting with features outside the scope of the Arduino library it is best to enable Transport Logging inside the URA to see what commands the URA is sending to the module. Within a new Arduino sketch send duplicates of the commands the URA is sending. The debug statements will help verify what you are sending and what was received.

Example 10 - Range Test

The PCB antenna on the shield will allow you to read tags up to around 24 inches at max read power (27dBm). If you really want to push the limit of read range you’ll need an external antenna. With a good external antenna we’ve seen read distances of up to 16 feet (4.5 meters)!

Keep in Mind: Ensure that personnel do not stand in the radiation beam of the antenna unless they are more than 21cm away from the face of the antenna (to adhere to FCC limits for long-term exposure). See Datasheet for more information.

Load Example10-Range Test onto your Arduino. As you bring a tag into range of the antenna you should hear a high pitched beep. When a tag is no longer detected you should hear a low pitched beep.

We are able to get more than 16 feet (4.5m) using the external antenna, with an external power supply (LiPo 1Ah battery), using SparkFun interface cables, and the URA software with the output power set to 27dBm. We didn’t heat sink the module but it quickly approached 60C as we were testing over the course of 5 minutes.

UHF Passive RFID range test

Large 7MB image showing distance from reader to tag

This is a large image but if you open the image in a new tab and look closely you’ll see the passive RFID tag hanging off the jaw of the T-Rex. Each carpet square is 2 feet and we were able to constantly read the tag more than 16 feet away! The NANO M6E is truly amazing.

But I’m not getting 16 feet!?

16 feet is really the best, most ideal situation. Our demonstration has no metal, no water, the tag is aligned with the antenna over open air and the power supply is as clean and powerful as possible (battery at 27dBm). Your real world results will vary greatly depending on many factors. It’s best to get the hardware and test in the environment your application will be within.

Check out our troubleshooting recommendations for RFID systems here.

Tag Location

Can I tell where a tag is located? Can I use UHF RFID for location within a room?

The short answer is no. The reader emits a ‘bubble’ of energy and any tag within that bubble will be energized and report itself to the reader. You’ll know if a tag is in the bubble but you won’t be able to tell where it is within the bubble. If your reader is capable of reading tags from 16 feet away, that’s amazing, but that means you won’t know if the tag is 1 foot or 10 feet from the reader. There is a caveat: the reader reports the RSSI (basically signal strength) for each tag. This means you’ll be able to tell qualitatively which tag is closer to the reader (tag 1 has a stronger signal so it’s roughly closer to the read than tag 2) but you won’t be able to tell quantitatively (you cannot tell if tag 1 is 1.5 feet or 2 feet from the reader).

Resources and Going Further

For additional help with this project, please check out the following resources.

We hope you enjoyed reading this tutorial! Have fun with your RFID projects! If you need more inspiration, check out these other tutorials from SparkFun:

SparkFun Blocks for Intel® Edison - Battery Block

A quick overview of the features of the Battery Block.

SparkFun Inventor's Kit for Photon Experiment Guide

Dive into the world of the Internet of Things with the SparkFun Inventor's Kit for Photon.

SparkFun Blocks for Intel® Edison - ADC V20

A quick overview of the features of the ADC Block.

Internet of Things Experiment Guide

The SparkFun ESP8266 Thing Dev Board is a powerful development platform that lets you connect your hardware projects to the Internet. In this guide, we show you how to combine some simple components to remotely log temperature data, send yourself texts and control lights from afar.