DIY FSK RFID Reader

This page describes the construction of an RFID reader using only an Arduino (Nano 3.0 was tested, but others may work), a hand-wound wire coil, and some assorted low cost common components.

Credits

The hardware and software designs for this project are based in part on the ideas, code and schematics posted by Micah Dowty here and Asher Glick here.

Background

RFID readers are devices sold by companies such as Parallax to read RFID tags with embedded identification circuits (we focus here on passive tags, activated by the reader's transmitted RF energy). The design presented here shows how to wind a simple wire loop by hand (or create an equivalent printed circuit spiral version), connect it to an Arduino (or its chip), add a few low cost common components and create your own RFID reader. To make it more interesting (i.e. challenging), we will focus on the FSK class of RFID tags, which are fairly common among the 125kHz devices, but for some reason are not supported by the Parallax kits.

Micah Dowty has shown a design for an FSK/ASK RFID reader built around a Parallax Propeller device. His code, which is in assembly language, implements an ingenious (but complex) algorithm to create a dynamically variable analog bias voltage, which is used to pull the weak RFID signal into range, so it can be discriminated into binary signals by the Propeller's digital input circuitry. He also dynamically tweaks the transmit/receive RF frequency to keep the antenna's tank circuit in peak resonance for optimal signal to noise. There are three problems with his approach: first, the passive detection circuit lacks amplification, which makes it very sensitive to noise and therefore raises reliability issues. Second, the design is based on the Propeller chip, and if you are a fan of the Arduino and/or associated Atmel AVR chips, it leaves you out. And third, the dynamic slewing of frequencies and bias voltage is overly complicated, making it hard to debug. His general concept is attractive, however: use a microcontroller chip and wind your own wire loop to create, with some simple components and appropriate code, a complete DIY RFID reader.

Asher Glick has presented a solution for reading and decoding FSK RFID tags using the Arduino/AVR family (which he calls AVRFID), which is good except it apparently requires obtaining and modifying an existing Parallax RFID reader device (which natively only supports ASK).

Our goal here is to present a simple solution for reading FSK tags which addresses the above shortcomings: make it robust and reliable for real-world noise environments, base it on the Arduino, and build the RFID reader ourselves using a few simple low-cost parts, rather than buying and/or modifying one.

Circuit

Arduino DIY FSK-RFID circuit diagram:

The circuit diagram above was derived from the "World's Simplest RFID Reader" design posted by Micah Dowty. Based on the Parallax Propeller, Micah's approach was to use passive components only, without amplification, in order to achieve the ultimate in simplicity. The lack of amplification, however, results in a weak signal, potentially less than 2V PTP. This signal is then biased by an analog level produced by the Propeller, to try to maintain the signal's DC level near the discrimination point of the Propeller's binary-digital input circuitry. His code attempts to dynamically calculate that optimal midpoint level, and feed it into the circuit using a filtered PWM DAC output. Since the signal is weak, it can be distorted by interference and noise, which results in reduced reliability. The circuit presented here includes (as Micah suggests in his documentation) one active component: a common low-cost LM234 quad-opamp IC (or equivalent). This addition provides several significant advantages, at a negligible cost. First, the signal is amplified (using one of the four opamps on the IC package) to a more noise-immune level (of 2-3 volts PTP). Second, the DC level of the signal is maintained at exactly Vcc/2 using another opamp on the IC, which eliminates the need for the DC propping code in the Arduino. Third, having the signal amplifier in place allows another low-pass RC filter stage (another capacitor and resistor), which makes the final discriminated digital signal cleaner and more reliable. The end result is a more robust detected signal with improved noise immunity.

As a quick review of the circuit, the loop is made of a toroidally-wound #22-30 magnet wire (we used an empty roll of Scotch 3.25" I.D. packing tape as former), and can be remoted from the circuit if needed, via coaxial cable. The inductor L1 and capacitance C1 should be matched to resonate at around 125 kHz. When driven at its resonant frequency by the Arduino's 0-5 volt square wave signal, the center point of the resonator (which connects to D1's cathode) will have a fairly pure voltage sine wave, of about 30V PTP. When coupled to an RFID tag, the pure sine wave RF will fluctuate visibly as the tag opens and closes its own loop antenna to repeatedly transmit its code. This modulation is then detected from the RF envelope by D1, C2 and R1, which produce a negative bias voltage with the small detected coded signal, e.g. about 11 RF cycles per coded cycle. The coded cycles are of two different wave lengths (or frequencies), which represent streams of logic ones and zeros, and they need to arrive at the Arduino chip as binary levels which can be timed reasonably accurately so as to reliably tell the difference between the two distinct frequencies.

The relatively large capacitor C3 decouples the negative bias voltage from the signal, and is followed by a low-pass RC filter stage (R2 and C4) which attenuates some of the residual RF spikes from the lower frequency coded RFID signal. Capacitor C5 decouples the resulting signal and presents it to the amplification stage, implemented by the LM324 opamp, IC1. The latter amplifies the weak signal from about .15V to about 3V PTP (depending of the ratio of R4 to R3), and places it on top of a Vcc/2 bias voltage, about 2.5V in the arduino's case. This signal is then fed into one of the digital input ports on the Arduino (which also includes some helpful hysteresis), and is discriminated by the internal comparator into a square wave of ones and zeroes.

Software

The Arduino sketch, derived from the code posted by Asher Glick, uses a single timer channel in the Arduino (using the Timer1 library) for both RF signal generation as well as timing clock to count the width of each input signal wave. There are two distinct cycle lengths in the detected input signal, "long" and "short", corresponding to logical ones and zeroes, respectively. A binary stream of stretches of repeated ones and zeroes is assembled, and then decimated into the original coded bits on the RFID tag, after decoding the Manchester encoding.

Here is the actual code:

  1. /*  Arduino program for DIY FSK RFID Reader
  2.  *  See description and circuit diagram at http://playground.arduino.cc/Main/DIYRFIDReader
  3.  *  Tested on Arduino Nano and several FSK RFID tags
  4.  *  Hardware/Software design is based on and derived from:
  5.  *  Arduino/Timer1 library example
  6.  *  June 2008 | jesse dot tane at gmail dot com
  7.  *  AsherGlick: / AVRFID https://github.com/AsherGlick/AVRFID
  8.  *  Micah Dowty:
  9.  *  http://forums.parallax.com/showthread.php?105889-World-s-simplest-RFID-reader
  10.  *
  11.  *  Copyright (C) 2011 by edude/Arduino Forum
  12.  
  13.  This program is free software: you can redistribute it and/or modify
  14.  it under the terms of the GNU General Public License as published by
  15.  the Free Software Foundation, either version 3 of the License, or
  16.  (at your option) any later version.
  17.  
  18.  This program is distributed in the hope that it will be useful,
  19.  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.  GNU General Public License for more details.
  22.  
  23.  You should have received a copy of the GNU General Public License
  24.  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  25.  
  26.  */
  27.  
  28. #include "TimerOne.h"
  29.  
  30. int ledPin = 13; // LED connected to digital pin 13
  31. int inPin = 7;   // sensing digital pin 7
  32. int val;
  33. int bitlenctr = 0;
  34. int curState = 0;
  35.  
  36. #define maxBuf 1000 //reduce to 100 or so for debugging
  37. #define debug  0
  38.  
  39. char raw[maxBuf];
  40.  
  41. int index = 0;
  42. int bufnum = 0;
  43. #define   redLED 12
  44. #define   grnLED 11
  45.  
  46. void setup()
  47. {
  48.   Serial.begin(9600);
  49.   Timer1.initialize(7);  // initialize timer1, and set the frequency; this drives both the LC tank as well as the pulse timing clock
  50.   // note: modify this as needed to achieve resonance and good match with the desired tags
  51.   // the argument value is in microseconds per RF cycle, so 8us will yield RF of 125kHz, 7us --> 143kHz, etc.
  52.  
  53.   Timer1.pwm(9, 512);           // setup pwm on pin 9, 50% duty cycle
  54.   Timer1.attachInterrupt(callback);  // attaches callback() as a timer overflow interrupt, once per RF cycle
  55.  
  56.   pinMode(ledPin, OUTPUT);      // sets the digital pin 13 as output for scope monitoring
  57.   pinMode(inPin, INPUT);      // sets the digital pin 7 as input to sense receiver input signal
  58.   pinMode(grnLED, OUTPUT);
  59.   pinMode(redLED, OUTPUT);
  60.   digitalWrite(grnLED, 0);
  61.   digitalWrite(redLED, 1);
  62. }
  63.  
  64. void callback()
  65. {
  66.   val = digitalRead(inPin);
  67.   digitalWrite(ledPin, val); // for monitoring
  68.   bitlenctr++;
  69.   if(val != curState) {
  70.     // got a transition
  71.     curState = val;
  72.     if(val == 1) {
  73.       // got a start of cycle (low to high transition)
  74.       if(index < maxBuf) {
  75.         raw[index++] = bitlenctr;
  76.       }
  77.       bitlenctr = 1;
  78.     }
  79.   }  
  80. }
  81.  
  82. void loop()
  83. {  
  84.   if(index >= maxBuf) {
  85.  
  86.     Serial.print("got buf num: ");
  87.     Serial.println(bufnum);
  88.  
  89.     if(debug) {
  90.       for(int i = 0; i < maxBuf;
  91.       i++) {
  92.           Serial.print((int)raw[i]);
  93.         Serial.print("/");
  94.       }
  95.       Serial.println("///raw data");
  96.       delay(2000);
  97.     }
  98.  
  99.     // analyze this buffer
  100.     // first convert pulse durations into raw bits
  101.     int tot1 = 0;
  102.     int tot0 = 0;
  103.     int tote = 0;
  104.     int totp = 0;
  105.     raw[0] = 0;
  106.     for(int i = 1; i < maxBuf; i++) {
  107.       int v = raw[i];
  108.       if(v == 4) {
  109.         raw[i] = 0;
  110.         tot0++;
  111.       }
  112.       else if(v == 5) {
  113.         raw[i] = raw[i - 1];
  114.         totp++;
  115.       }
  116.       else if(v == 6 || v == 7) {
  117.         raw[i] = 1;
  118.         tot1++;
  119.       }
  120.       else {
  121.         raw[i] = 101; // error code
  122.         tote++;
  123.       }  
  124.     }  
  125.  
  126.     // next, search for a "start tag" of 15 high bits in a row
  127.     int samecnt = 0;
  128.     int start = -1;
  129.     int lastv = 0;
  130.     for(int i = 0; i < maxBuf; i++) {
  131.       if(raw[i] == lastv) {
  132.         // inside one same bit pattern, keep scanning
  133.         samecnt++;
  134.       }
  135.       else {
  136.         // got new bit pattern
  137.         if(samecnt >= 15 && lastv == 1) {
  138.           // got a start tag prefix, record index and exit
  139.           start = i;
  140.           break;
  141.         }
  142.         // either group of 0s, or fewer than 15 1s, so not a valid tag, keep scanning
  143.         samecnt = 1;
  144.         lastv = raw[i];
  145.       }  
  146.     }
  147.  
  148.     // if a valid prefix tag was found, process the buffer
  149.     if(start > 0 && start < (maxBuf - 5*90)) { //adjust to allow room for full dataset past start point
  150.       process_buf(start);
  151.     }
  152.     else {
  153.       Serial.println("no valid data found in buffer");
  154.     }
  155.     if(debug) {
  156.       for(int i = 0; i < maxBuf;
  157.         i++) {
  158.           Serial.print((int)raw[i]);
  159.         Serial.print("/");
  160.       }
  161.       Serial.print("///\nbuffer stats: zeroes:");
  162.       Serial.print(tot0);
  163.       Serial.print("/ones:");
  164.       Serial.print(tot1);
  165.       Serial.print("/prevs:");
  166.       Serial.print(totp);
  167.       Serial.print("/errs:");
  168.       Serial.println(tote);  
  169.       delay(1000);
  170.     }
  171.  
  172.     // start new buffer, reset all parameters
  173.     bufnum++;
  174.     curState = 0;
  175.     index = 0;
  176.   }
  177.   else {
  178.     delay(5);
  179.   }  
  180. }
  181.  
  182. // process an input buffer with a valid start tag
  183. // start argument is index to first 0 bit past prefix tag of 15+ ones
  184. void process_buf(int start) {
  185.   // first convert multi bit codes (11111100000...) into manchester bit codes
  186.   int lastv = 0;
  187.   int samecnt = 0;
  188.   char manch[91];
  189.   char final[45];
  190.   int manchindex = 0;
  191.  
  192.   Serial.println("got a valid prefix, processing data buffer...");
  193.   for(int i = start + 1; i < maxBuf && manchindex < 90; i++) {
  194.     if(raw[i] == lastv) {
  195.       samecnt++;
  196.     }
  197.     else {
  198.       // got a new bit value, process the last group
  199.       if(samecnt >= 3 && samecnt <= 8) {
  200.         manch[manchindex++] = lastv;
  201.       }
  202.       else if(samecnt >= 9 && samecnt <= 14) {
  203.         // assume a double bit, so record as two separate bits
  204.         manch[manchindex++] = lastv;
  205.         manch[manchindex++] = lastv;
  206.       }
  207.       else if(samecnt >= 15 && lastv == 0) {
  208.         Serial.println("got end tag");
  209.         // got an end tag, exit
  210.         break;
  211.       }
  212.       else {
  213.         // last bit group was either too long or too short
  214.         Serial.print("****got bad bit pattern in buffer, count: ");
  215.         Serial.print(samecnt);
  216.         Serial.print(", value: ");
  217.         Serial.println(lastv);
  218.         err_flash(3);
  219.         return;
  220.       }  
  221.       samecnt = 1;
  222.       lastv = raw[i];
  223.     } //new bit pattern
  224.   }
  225.  
  226.   Serial.println("converting manchester code to binary...");
  227.   // got manchester version, convert to final bits
  228.   for(int i = 0, findex = 0; i < 90; i += 2, findex++) {
  229.     if(manch[i] == 1 && manch[i+1] == 0) {
  230.       final[findex] = 1;
  231.     }
  232.     else if(manch[i] == 0 && manch[i+1] == 1) {
  233.       final[findex] = 0;
  234.     }
  235.     else {
  236.       // invalid manchester code, exit
  237.       Serial.println("****got invalid manchester code");
  238.       err_flash(3);
  239.       return;
  240.     }
  241.   }
  242.  
  243.   // convert bits 28 thru 28+16 into a 16 bit integer
  244.   int code = 0;
  245.   int par = 0;
  246.   for(int i = 28, k = 15; i < 28+16; i++, k--) {
  247.     code |= (int)final[i] << k;
  248.   }
  249.   int paritybit = final[28+16];
  250.   for(int i = 0; i < 45; i++) {
  251.     par ^= final[i];
  252.   }
  253.  
  254.   if(par) {  
  255.     Serial.print("got valid code: ");
  256.     Serial.println((unsigned int)code);
  257.     // do something here with the detected code...
  258.     //
  259.     //
  260.     digitalWrite(redLED, 0);
  261.     digitalWrite(grnLED, 1);
  262.     delay(2000);
  263.     digitalWrite(grnLED, 0);
  264.     digitalWrite(redLED, 1);
  265.   }
  266.   else {
  267.     Serial.println("****parity error for retrieved code");
  268.     err_flash(3);
  269.   }  
  270. }
  271.  
  272. // flash red for duration seconds
  273. void err_flash(int duration) {
  274.   return;
  275.   for(int i = 0; i < duration*10; i++) {
  276.     digitalWrite(redLED, 0);
  277.     delay(50);
  278.     digitalWrite(redLED, 1);
  279.     delay(50);
  280.   }
  281. }
  282.  

Status

The device and transceiver antenna have been built and tested on multiple FSK RFID tags of various kinds, in breadboard and soldered perfboard versions, connected to remote and local probes. When the probe is properly tuned, the device can reliably detect FSK RFID tags within a range of 0 to at least 2 inches from the coil, although it may be possible that this can be extended with larger coil sizes and/or other optimizations. The circuit has also been simulated on Spice, as described below.

Spice simulation

LTspiceIV simulated waveforms of FSK RFID reader plus transponder tag:

As seen in the LTspiceIV screenshot above, the circuit (with a passive virtual ground reference - see note below) was simulated on a computer, and the results confirmed the essential design, closely replicating the waveforms actually seen on the oscilloscope. The RFID transponder tag was simulated as a coupled transformer winding with a resonantly tuned capacitor, shunted to ground by a square-wave signal. The RFID tag's ground is connected to the main circuit's ground for simulation purposes. The inductive coupling between the two "transformer windings" is a variable which can be changed in LTspice, and was varied for testing between 1 and 0.01 (0.015 is shown in the waveforms above), equivalent to having the RFID tag positioned at different distances from the reader coil.

Notes

  • The Vcc/2 virtual ground voltage for IC1's non-inverting input can also be taken directly from the midpoint of the 100K voltage divider resistors, bypassing the second opamp. In such a case, the divider's midpoint should be connected to pin3 of IC1 via a 1M resistor.

References

Share