Because of their widespread use, most magnetic cards adhere to well-defined standards that describe the physical and magnetic characteristics for a magnetic stripe on a plastic card. These standards outline specifications for a storage format and information interchange. This does not preclude other encoding techniques or additional data tracks for specific applications, but in most cases it makes sense to adhere to at least the basic constraints. This gives you the choice of using any commercially available magnetic encoders for your application.
The technique used for encoding magnetic cards is known as “Two-Frequency, Coherent Phase Recording”. Allowing for the representation of single-channel, self-clocking serial data, this methodology is generally referred to as F/2F. Self-clocking is achieved by combining data and clock bits together in a continuous, synchronous sequence. In this scheme, an intermediate flux transition signifies a one bit and the absence of an intermediate flux transition denotes a zero bit.
Three data tracks defined for use on standard magnetic cards each possess different bit densities and encoded character sets. The average bit density of track 1 is 210 bits per inch (bpi). Track 1 characters are made up of six data bits and an odd parity bit, encoded with the least-significant bit first and the parity bit last, yielding a 64-character set. Taking the number of bits per inch and the number of bits per character, you can see track 1 has the capacity to hold 79 characters.
Track 2 has a bit density of 75 bpi, and track 3 uses 210 bpi. Both of these tracks allow the representation of a numeric-only character set. The characters for tracks 2 and 3 are encoded using a 4-bit binary-coded decimal subset with odd parity and, like track 1, are encoded with the least significant bit first and the parity bit last. The lower density of track 2 allows up to 40 numeric characters, where 107 numerics can be squeezed onto track 3. The actual number of usable characters will be fewer since you also have the Start Sentinel, End Sentinel, and LRC characters.
Though sometimes magnetic cards are moved past the read head mechanically, most applications rely on manually moving the card, either through a slotted reader or into an insertion-type reader. Typically the swipe rate is 5-20 inches per second (ips), with 50 ips being the fastest most card readers can handle. Of course, moving the card by hand will not only result in varying the absolute card velocity but, will also introduce incremental speed changes as the card accelerates and decelerates past the pickup. The F/2F scheme is very forgiving of such speed fluctuations.
For all 3 tracks, the fundamental data format is similar and consists of the following elements: First, leading zero bits are encoded to indicate the presence of an encoded magnetic card and provide synchronization pulses to the read head electronics and ultimately to the controller. Next, the Start Sentinel character is encoded which indicates the start of the actual data. The coded data follows. Next, the End Sentinel terminates the data portion of the card and followed by an LRC byte (used for error detection). The LRC is essentially a horizontal parity calculated by an exclusive-OR of all the data bits from the Start Sentinel to the End Sentinel (inclusive). Finally, trailing zeros follow the LRC and fill out the remainder of the card.
ANATOMY OF A MAGNETIC CARD
The magnetic tracks have inherent characteristics based on details such as code set and bit and character densities. International organizations such as Mastercard and VISA impose additional constraits for their participating members and standards exist for bank debit cards and ATM cards as well. These rules specify the exact content and format of each data field in aech track as well as the intended uses for the tracks. Naturally, for nonfinancial uses, it is not necessary to comply with these standards. For dedicated uses such as access control, people tracking, and material tracking, adhering to the minimal standards is adequate.
The most-often-used track is track 2, although it offers the lowest inform- ation density of the three. It contains all the information that is normally used for credit card transactions. When a customer name is required, track 1 must be used since it is the only track that permits alphanumeric data. Track 3 is specified for numeric-only data, but is unique. It is intended for change- able data and consequently may not only be read but may be rewritten by the transaction-handling equipment. A multitude of data fileds are contained in these various tracks. Figure 1 shows a brief run-down of what is generally placed on tracks 1 and 2.
REAL CARD READERS
The recovery of magnetically encoded F/2F data can be accomplished directly with the use of just about any microcontroller. There are no particular difficulties in deciphering the raw F/2F data stream and many early magnetic read heads contained nothing more than signal amplifiers and line drivers. These are now artifacts since all modern magnetic read heads contain integ- rated F/2F bit recovery circuitry and interface with the host controller in a standard fashion using three wires: CARD PRESENT, CLOCK, and DATA. The read heads usually rely on a single chip to perform the linear signal conditioning, sychronization, and recovery of individual bits from the data stream. The Mag- Tek 21006505 IC is representative of this type of data recovery circuit and its functionality is depicted in figure 2.
Linear conditioning consists of raising the level of the magnetic pickup’s input signal, rejecting common-mode noise, conditioning and detecting the signal, and finally providing a digital output for susequent processing. The enable/disable counters provide initialization for the recovery section. The recovery section locks onto the data rate and recovers the individual data bits from the data stream. The oscillator section provides the clocks for the recov- ery section and for the enable/disable timers. Card present goes low after 8 or 9 flux reversals are seen from the magnetic pickup and will return high about 50 ms after the last flux reversal. The strobe line signals that data is valid and is active low. The data pin indicates a one bit when it is low. Raw F/2F data can also be picked directly off the chip.
The data rate for a high-density track scanned at 50 ips comes to 10500 bits per second (bps). This results in a transfer rate of 1500 characters per second for the 7-bit elements used on track 1, and 2100 characters per second using the 5-bit elements of track 3. I either case, this translates to a new bit arriving at the controller just under every 100 us (microsecond). Even the most anemic controller should be able to keep up. With resonably good coding techni- ques, there should be no problem handling the entire data sampling phase on an interrupt-driven basis. The low-density (track 2) data flows at a more pedes- trian 3750 bps, yielding 750 5-bit characters per second, or a new bit every 266 us. Since most dual-track read heads provide track 1 and track 2 data, this indicates that handling both tracks simultaneously is feasible under interrupt control. Keep in mind that 50 ips is a rather fast scan rate; 20-30 ips is probably a more realistic limit.
MAGNETIC BIT STORMS
When approaching a problem such as decoding magnetic cards, it pays to spend some time looking at the overall picture before starting to write the code. At first glance, it would seem that organizing the data into the prevailing element size during the sampling interval would make decoding easier. This could be easily done by ignoring all the leading zeros, with actual data storage comm- encing with the first one bit. Of course, this approach assumes you’re getting good data. The fact that the data recovery is handled using well-proven hard- ware makes this assumption valid.
If all you need to do is decode the card in a forward direction, then going about things as I just described makes sense and reduces the coding effort to a trivial exercise. If you have to support reverse decoding then this is not the optimal solution. Having considered the tradeoffs of being able to decode a magnetic card in both forward and reverse directions, I decided to structure the program to work equally well in either direction at the cost of a slight increase in initial complexity.
The first step in decoding is to acquire the serial bit stream. This can be done using a dedicated sample loop or, with a little more work, using interrupt processing. Since the idea is the same regardless of the details, I decided to use a sample loop in my demonstration program (listing 1). The code simply records the incoming data stream and deposits the data in a sample buffer a byte at a time. Sampling begins when Card Present returns idle. Any incomplete byte that has been partially assembled at the time when sampling terminates is simply discarded. The abundance of leading and trailing zeros allows losing some bits at either end causing any problems.
LISTING 1-- Using several externally defined routines, a sample program to read a stripe and store it in a buffer is very short. PUBLIC READ_MAG1 EXTERN MS1_BUF (XDATA) ;sample buffer EXTERN MS1_LIM (NUMBER) ;sample limit EXTERN MD1_BUF (XDATA) ;decode buffer EXTERN CP (BIT) ;card present bit EXTERN M1_CLK (BIT) ;clock bit EXTERN M1_DQ (BIT) ;data bit M1_SS EQU 5 ;start sentinel M1_ES EQU 1FH ;end sentinel ; SEG CODE ;Sample and decode magnetic track 1 ; output: ACC contains character count. ; DPTR points to data buffer READ_MAG1 PROC CALL MAG_SAMPLE JZ L?RM1 CALL MAG1_DECODE L?RM1: RET ENDPROC ;General-purpose magnetic sampling routine ; output: ACC contains sample count MAG_SAMPLE PROC MOV DPTR,#MS1_BUF MOV R1,#0 ;sample counter L?MS1: MOV R0,#8 ;bit counter L?MS2: JB CP,L?MS4 JB M1_CLK,L?MS2 MOV C,M1_DQ L?MS3: JB CP,L?MS4 JNB M1_CLK,L?MS3 CPL C RRC A DJNZ R0,L?MS2 MOVX @DPTR,A INC DPTR INC R1 ;sample counter CJNE R1,#MS1_LIM,L?MS1 L?MS4: MOV A,R1 ;final sample count RET ENDPROC
Once the sampling interval completes, control is transferred to the decoding algorithm. Presented in listing 2, the track-1 decode algorithm consists of nothing more than some initialization and the essence of the decode logic. Limiting the gyrations contained in the main body of this routine not only makes the logic easy to follow, but permits the same code to handle the decoding in either a forward or reverse direction.
LISTING 2-- Once the serial bit stream has been acquired, the decoding algorithm takes over. ;Bidirectional magnetic track 1 decode routine ;input: sample count in ACC, output: ACC contains character count ; DPTR points to decoded data buffer ;Reg. usage for this routine (includes subroutines) as follows: ;R5: Direction flag, 0=forward ;R4: Cumulative LRC register ;R3: Decoded character counter ;R2: Nondecrementing sample count ;R1: Decrementing sample count ;R0: Bit syncronizing counter MAG1_DECODE PROC ;1st pass, setup for forward decode attempt MOV R5,#0 ;indicate forward decode MOV DPTR,#MS1_BUF ;point to start of buffer MOV R1,A ;sample counter MOV R2,A ;sample count JMP L?M1D1 L?M1D0: ;2nd pass, setup for reverse decode attempt MOV R5,#1 ;indicate reverse decode MOV DPTR,#MS1_BUF MOV A,R2 ;sample count DEC A ADD A,DPL MOV DPL,A CLR A ADDC A,DPH MOV DPH,A ;point to end of buffer MOV R1,2 ;sample counter L?M1D1: ;decode initialization MOV R3,#0 ;character counter MOV R4,#0 ;inital LRC MOV R0,#0 ;bit syncronizer CALL FIND_START ;main decode loop JNC L?M1D5 ;start bit error CALL GET_CHAR ;Start Sentinel JB ACC.7,L?M1D5 ;format error CJNE A,#M1_SS,L?M1D5 ;start setinel error L?M1D2: ;data byte or End Sentinel CALL GET_CHAR JB ACC.7,L?M1D5 ;format error CJNE A,#M1_ES,L?M1D3 ;end sentinel not found JMP L?M1D4 L?M1D3: CALL STORE_CHAR ;data character JMP L?M1D2 L?M1D4: ;LRC CALL GET_CHAR ;get LRC JB ACC.7,L?M1D5 ;format error MOV A,R4 JNZ L?M1D5 ;LRC error MOV DPTR,#MD1_BUF ;good return MOV A,R3 ;final character RET L?M1D5: ;decode error, check if 1st pass CJNE R5,#1,L?M1D0 ;check direction CLR A ;bad return RET ENDPROC
The initial entry point assumes a forward decode attempt and sets up the necessary flags, pointers, and counters before jumping into the main initial- ization code. After initialization, the sample buffer is scanned for the first one bit, at which time a 7-bit element is assembled. If the parity is correct and the character code checks out to be a Start Sentinel, the code proceeds and starts pulling successive data elements from the sample buffer. If the data element is not an End Sentinel, the character is translated to ASCII and stored in the decode buffer. Should an End Sentinel be detected, the program extracts the next character, which is assumed to be the LRC byte, and finally checks the calculated LRC for a value of zero.
The checks and balances included in the execution of this loop include things such as parity, a cumulative LRC, and checking to make sure I haven’t run out of samples. If everything checks out, the program terminates and returns with the DPTR pointing to the decoded data buffer and the character count contained in ACC. Should a decode failure occur, a test is performed on the direction flag and if this is an attempt at a forward decode, the routine jumps to the reverse initialization entry point. The reverse entry is similar to the forward decode entry but sets up the sample pointer to the end of the sample buffer and sets the direction flag to indicate a reverse operation.
The routines contained in the intermediate layer are shown in listing 3. The meaning and operation of these routines should be apparent. The key routine in this section is GET_BIT, which picks off the next bit from the sample buffer, essentially restoring the sequential nature of the initial magnetic bit stream. FIND_START is used to synchronize with the first one bit. GET_CHAR first checks to make sure it hasn’t run out of samples, then assembles the next 7-bit data element while doing a parity test and LRC calculation. Any problems encountered here are sent back to the caller and are handled there. STORE_CHAR translates and deposits the data character into its respective location in the decoded-data buffer and increments the character counter.
LISTING 3-- The intermediate layer of software is one level removed from the nitty-gritty details. ;Get the next bit from the sample buffer ;output: C contains data bit GET_BIT PROC CJNE R0,#0,L?GB1 ;bit synchronizer MOV R0,#8 PUSH ACC MOVX A,@DPTR CALL INDEX_PTR MOV B,A POP ACC DEC R1 ;sample counter L?GB1: XCH A,B CALL POSITION_BIT XCH A,B DEC R0 ;bit synchronizer RET ENDPROC ; ;Find the first '1' bit in the sample buffer ;output: C=1 if bit is found FIND_START PROC L?FS1: CJNE R0,#0,L?FS2 ;bit synchronizer MOV R0,#8 MOVX A,@DPTR CALL INDEX_PTR DJNZ R1,L?FS2 ;sample counter JMP L?FS4 ;out of samples L?FS2: CALL LOCATE_BIT ;test for a '1' bit JC L?FS3 CALL POSITION_BIT DEC R0 ;bit synchronizer JMP L?FS1 L?FS3: ;good return MOV B,A ;save copy in B SETB C RET L?FS4: CLR C ;bad return RET ENDPROC ; ;Get the next 7 bit element from the sample buffer ;output: ACC contains data element ; error flag is ACC.7 GET_CHAR PROC MOV A,R1 ;sample counter JZ L?GC2 ;out of samples MOV R7,#7 ;bit counter CLR A L?GC1: CALL GET_BIT ;next bit RRC A DJNZ R7,L?GC1 RR A JNB P,L?GC2 ;parity error ANL A,#3FH ;discard parity PUSH ACC XRL A,R4 ;calculate LRC MOV R4,A POP ACC ;good return RET L?GC2: SETB ACC.7 ;bad return RET ENDPROC ;Translate and store the data character ;input: ACC contains data character STORE_CHAR PROC PUSH DPL PUSH DPH PUSH ACC MOV DPTR,#MD1_BUF MOV A,R3 ;character counter ADD A,DPL MOV DPL,A CLR A ADDC A,DPH ;generate displacement MOV DPH,A POP ACC ADD A,#' ' ;translate MOVX @DPTR,A ;store POP DPH POP DPL INC R3 ;character counter RET ENDPROC
Listing 4 shows the low-level code. These routines perform the most rudiment- ary functions and operate in accordance with the direction flag. INDEX_PTR either increments or decrements the sample pointer, POSITION_BIT likewise does either a right or left shift and LOCATE_BIT returns the state of the least- or most- significant bit of the accumulator.
LISTING 4-- The low-level routines get right down to the ground and take care of the gory details. ;Index the sample pointer either forward or backward INDEX_PTR PROC CJNE R5,#0,L?IP1 ;check direction INC DPTR ;forward RET L?IP1: PUSH ACC ;backward DEC DPL MOV A,DPL CJNE A,#-1,L?IP2 DEC DPH L?IP2: POP ACC RET ENDPROC ;Position bit is in ACC into C in either a right or left shift POSITION_BIT PROC CJNE R5,#0,L?PB1 ;check direction RRC A ;forward RET L?PB1: RLC A RET ENDPROC ;Locate a 1 bit, either msb or lsb ;output: C=1 if bit is a one LOCATE_BIT PROC CJNE R5,#0,L?LB1 ;check direction MOV C,ACC.0 ;forward RET L?LB1: MOV C,ACC.7 ;backward RET ENDPROC
GO AHEAD, TAKE A SWIPE
Let me touch on a few additional points that may not be immediately apparent before signing off. Storing the sampled data in a continuous stream makes the sample routine work equally well with the various bit configurations used for the different recording tracks. This would not be easily attained if you tried to generate a particular element format during sample time. Furthermore, if you look at the differences between the encoded character sets and the bit formats for the different tracks, you will find that they differ in only a few areas. With a few minor changes, such as the defined Start Sentinel, number of bits per element, and character translation method, the decode routine I’ve shown could easily be coerced to handle the decoding of any of the standard magnetic tracks.
As a matter of fact, by recoding and redefining the hard-coded constants as variables, these could be set up for the particular data track at execution time before invoking the decode function. Doing so would not only save program memory, but would also allow you to use a routine you were comfortable with.