Summary of replies to the following request:
Subject: Mag Card Swipe Reader: Need Help!
Hello, Everybody.
I just
picked up one of those swipe readers for mag stripes on credit
cards etc. from a surplus
outfit (American Science & Surplus in
Evanston, IL 708/475-8440 for those who are
interested). It’s not the
complete unit with keypad, display, etc. but rather just the guts of
the
subassembly which actually reads the card (hey, what do you expect for
$2.50?? 
Since it’s surplus and taken out of a larger piece of
equipment, I have no docs for this
sucker. My hope is that someone else
picked up one of these things to play with and has some
docs or has figured
out enough about it to get it to work, OR can tell me who to contact to
get
more info on this beast. I figured this would be a good place to ask
since I’ve seen
people asking about swipe card readers recently.
Anyway, here’s a description:
The unit is about 6" long, 1" wide, and maybe 2" high. It consists of a
metal
backing plate, attached to which is a black plastic guide channel
through which you swipe the
card. On one side of the plastic channel is a
read head for the mag stripe; on the opposite
side is a small printed circuit
board.
Removing the plastic guide from the
mounting plate reveals that the
manufacturer is SR&D corporation of Tokyo, Japan. The
model number is
MCR-175-1R-0803; a serial number is also listed. The SR&D
logo-lettering
appears on the component side of the PC board, and on the foil side of
the board the SR&D is repeated along with the code "FNC -065-1" in the
upper
right hand corner. The board has one IC on it (I can’t easily see
what the numbers are on this
chip, so I’m not sure what kind it is other
than a 16 pin DIP). There is a spot for another
chip, an 8-pin DIP for
which the screened label reads "IC2 6914", but this chip and
some other
resistors, capacitors, etc. are missing.
Finally, there are 5 wires
coming from the assembly and terminating in a
small connector similar to power supply
connectors for 3.5" floppy drives.
The wires are red, yellow, green, blue, and black.
I haven’t hacked on this thing at all yet, since I don’t know what its
power
requirements are or even which are power leads and which are data
leads. If anyone has any
information on this puppy which might help me,
I’d love to hear from you! Please email me.
I’ll share whatever I find
out with anyone who’s interested.
Thanks!
—
[Editor's Note: The following is a concatenation of the replies I received
to
the net.request above. After the replies I have included information
which was posted to the
net on how mag stripe cards are encoded (in case
anyone missed it). Finally, I have included
some software that I threw
together to play with the card reader. This file contains all the
information
I have on this subject. Additions are most welcome.
You'll notice I
didn't get any farther than simply reading the raw signal
from the card; of the two card
readers I ordered, one was completely DOA,
and the other had a faulty clock output (at least I
assume that it was a
clock output; I was never able to read any sort of signal from that
line).
Someone with a fully functional reader can easily extend what I wrote to get
it
to decode the actual data content of the card. If you do decide to make
modifications and/or
extensions, I'd appreciate a copy of whatever
changes you make (email to tmkk@uiuc.edu).
Enjoy!]
Subject: Re: Mag Card Swipe Reader: Need Help!
I am truly
amazed that someone else is trying to use this device! I got
mine about 2 years ago and spent
some time trying to find the manufacturer.
I found a listing for SR&D in the Noth America
technical directory at
the public library. I found the listing for the American sales
office
in Los Angeles. I tried calling but the company had gone out of
business. There
was no listing in the local phone directory either.
I then tried calling the head office in
Japan, but they also had
gone out of business. I haven’t seen the company listed in any
recent
electronics directories, so I think they really are gone.
I have spent
about an hour looking at the signals on the outputs
of the device. One signal line is a
/STATUS line which indicates
when a card is been moved through the unit. The other 2 lines
Manchester decoding and
clock recovery for the read channel, so one
output line is DATA and the other is CLOCK.
That is as far as I got 2 years ago and I had forgot about it until
now. If you receive
any other info, please send a copy to me!
—
>Finally, there are 5
wires coming from the assembly and terminating in a
>small connector similar to power
supply connectors for 3.5" floppy drives.
>The wires are red, yellow, green, blue, and
black.
If its anything like the units I worked with, I think you will find
that
the five wires are:
+5v
Gnd
Clock
Data
Card detected
—
I picked few
week ago a magnetic credit card reader from a
another surplus outfit. It cost about the sam
es yours.
My card reader was made by MAGTEK and was diffrent from
your reder in many
ways. The reader I have has 4 ICs and
some of them are standard TTL chip, so I could easily
quess the power requiments (5V) and power connectors.
My card reader had 6 pin
connector.
I put the power to the reader and started to examine
the signals with
multimeter and a little crystal
earphine (my favourite electronics hacking tool).
I
found that output signals were something like
that: data out, data clock out, data readable
and
and card ath the end of the reader.
Then I connected the reader to the joystick
port
of my 386SX and made a little Turbo Pascal program
for reading the card.
diffrent hardware circuit
to my computer. This time I decided
to use game port beacuse it can also provide the power to
the
reader.
My program simply prints out the bits from the card. I have not
found the way to decode the bits to corresponding numbers. The
program so prints all 237 bits
form the card to screen.
If you have any information about data coding, I an interrested
in hearing that.
Here is the meanings of the bytes in port $201:
D7: 0 -> card
pushed to the end of the reader
D6: the read data from card
D5: 0 -> data stream
readable
D4: the data clock
Program CardReader;
Uses Crt,Binary;
Const
gameport=$201;
Procedure Wait_start;
Begin
Repeat Until (Port[gameport] and 32)=0;
End;
Function data_readable:boolean;
data_readable:=((Port[gameport] and 32)=0);
End;
Procedure
Wait_clock;
Begin
Repeat Until (Port[gameport] and 16)=0;
End;
Procedure Wait_clock_end;
Begin
Repeat Until (Port[gameport] and 16)=16;
End;
Function data_input:byte;
Begin
If (Port[gameport] and 64)=0 Then
data_input:=0
Else data_input:=1;
End;
Function card_at_end:boolean;
Begin
card_at_end:=((Port[gameport] and 128)=0);
End;
Procedure test;
Begin
Wait_start;
Repeat
Writeln(ByteBin(Port[$201]));
Until keypressed;
Begin
ClrScr;
Wait_start;
While data_readable Do Begin
Wait_clock;
Write(data_input);
Wait_clock_end;
End;
Repeat Until
KeyPressed;
End.
—
Wiring color code for the SR&D
MCR-175-1R-0803 mag stripe card reader:
Red: +5V
Black: Gnd
Yellow: /Card
Detect
Green: Clock (?? - non-functional on the unit I have)
Blue: /Data
The leading ‘/’ indicates an active low TTL signal.
—
Quick ‘n Dirty guide to the enclosed reader software
—————————————————-
Hooking the SR&D
MCR-175-1R-0803 card reader to your PC:
The included software is written specifically
for the following
configuration; if your wiring is different, you’ll need to make
corresponding changes to the software. Note also that the port
address is hard-coded to look
for LPT2’s status port (at address
0×279). If you’re using a different port address, be sure
to change the
port address value.
SR&D Wire Printer Port Pin Port Bit
Signal
——— —————- ——– ——
Yellow 11 7 /CARD DETECT
Blue 10
6 /DATA
Black 18 N/A (Ground)
Power to the reader was provided by a separate
power supply, basically
one of those black plastic DC power packs fed through a 7805
regulator
chip.
Compiling the software:
Compile SWIPE.C
(using SMALL memory model), assemble SWIPEISR.ASM, and
link the two together.
To use SWIPE.EXE, simply hook the reader up to your LPT2: port,
power it
up, then run SWIPE. When you’re ready, press the ENTER key, and swipe a
card
through the reader. The program will read the data from the card and
store it in a buffer (but
will not decode the data; that is left as an
excercise ;-). After the card has been read,
press ENTER again and the
contents of the buffer will be dumped to stdout. To save the card
data to
a file, simply redirect SWIPE’s output on the command line, e.g.
SWIPE
> citibank.out
Please let me know of any changes, bug fixes, or improvements you
make to
this code. Send email to tmkk@uiuc.edu.
Thanks, and have fun!
/*
* S W I P E . C
*
* Written:
*
1/11/92
*
* Description: Quick ‘n Dirty reader program for SR&D mag stripe card
reader.
* Reads data from the input port as long as a card is detected in the
* card
slot. After sampling, the data is dumped to stdout, and may
* be redirected to a file if
desired.
*
* Note: Written for Borland C++ 3.0 - may require changes to compile under
*
*/
#include
<stdio.h>
#include <conio.h>
#include <process.h>
#include
<dos.h>
#include <math.h>
#include <stdlib.h>
#include
<assert.h>
#include <string.h>
/* timer chip programming register
port addresses */
#define COMMAND_REG 0×43
#define CHANNEL0 0×40
/* size of
sample buffer */
#define MAXSAMPLE 4096
typedef unsigned char byte;
/* global variables */
byte *databuf; /* buffer for the sampled data */
/*
interprocess communication data */
byte *bufp; /* data buffer pointer */
unsigned nsamp;
/* number of samples to be made */
unsigned port; /* input port address */
int enab=0;
/* flag to enable/disable sampling */
int start=0; /* flag indicating that sampling has begun
*/
/* ISR prototype */
extern void interrupt shand(void);
/*
* P R O G R A M _ T I M E R
*
* Description: Programs the given count value into the specified channel of
* the IBM
825x timer chip. Channel 0 is the time-of-day-clock interrupt;
* channel 2 is the speaker
pulser.
*
* Parameter:
* channel (in) - Channel to be programmed.
* count
(in) - Count value with which to program timer chip.
*
*/
{
outportb(COMMAND_REG, 0×36); /* set up for reprogramming */
outportb(CHANNEL0 + channel, count
& 0xff); /* lo byte first */
outportb(CHANNEL0 + channel, count >> 8); /* then hi
byte */
}
void sample_data(int count)
/*
* S A M P L E _ D A T A
* Description: Sets up for data collection from the printer port using
* the SHAND
interrupt service routine (see SWIPEISR.ASM). This routine
* reprograms the timer chip for the
desired sampling rate, sets up
* the interprocess communication area, and starts the sampling
process.
* The actual sampling is done in the SHAND procedure. This routine
* waits
until sampling has been completed before returning.
*
*/
{
void interrupt
(*oldhand)(void); /* pointer to old interrupt vector */
/* save old interrupt vector
*/
oldhand = getvect(0×1c);
/* clear enable flag */
enab = 0;
start =
0;
/* install new vector */
setvect(0×1c, shand);
/* set up
interprocess communications area */
nsamp = 0;
bufp = databuf;
port = 0×279; /*
address of printer status register */
cprintf("Sampling at %fHz (=
%fms)….",
1193180.0 / (float)count, (float)count / 1193.18);
/* reprogram
timer chip */
program_timer(0, count);
/* enable sampling */
enab = 1;
/* wait until sampling is completed */
while (enab) ;
/* restore
standard timing value */
program_timer(0, 0);
/* reinstall old handler vector
*/
setvect(0×1c, oldhand);
cprintf(" completed.\r\n");
}
void main()
{
unsigned i;
/* allocate memory */
databuf = calloc(MAXSAMPLE, sizeof(byte));
assert (databuf != NULL);
cprintf("Press <ENTER> when ready to swipe card:");
getchar();
sample_data(12); /* This works out to about a 100kHz sampling rate */
cprintf("Sampling completed, %u samples total.\r\n", nsamp);
cprintf("Press
<ENTER> to dump data.\r\n\r\n");
getchar();
/* dump data to stdout
*/
for (i=0; i<nsamp; ++i)
if (kbhit())
break;
else
printf("%u\n", databuf[i]);
free (databuf);
}
—
CUT HERE —
;
; S W I P E I S R . A S M
;
; Interrupt Service
Routine to sample swipe reader.
;
_TEXT segment byte public ‘CODE’
DGROUP group _DATA,_BSS
assume cs:_TEXT,ds:DGROUP,ss:DGROUP
_TEXT ends
_DATA segment word public ‘DATA’
; Nuthin’ in here!
_DATA ends
_BSS segment
word public ‘BSS’
; Nuthin’ in here either!
_BSS ends
_TEXT segment byte
public ‘CODE’
;
; S H A N D
;
; Description: Sample interrupt handler for
timer extension interrupt 0×1c.
;
; Note: Assumes that the /CARD DETECT line appears on
bit 7 of the input
; port. This bit corresponds to pin 11 on the standard PC printer port.
; bit 7 is *set*
when a card is in the reader, even though /CARD DETECT
; is an active low signal.
;
push ax
push bx
push dx
push ds
push si
push di
push bp
mov bp,DGROUP
mov ds,bp
cmp word ptr DGROUP:_enab, 0
; Are we turned on?
je ciao ; Nope - goodbye!
mov dx, word ptr DGROUP:_port ; Get
port address
cmp word ptr DGROUP:_start, 0 ; Has sampling begun?
jne doit ; Yup - hop to
it!
;
; Sampling is enabled but has not actually begun because no card has yet
been
; detected in the slot of the reader. Check to see if a card has arrived
; yet and,
if it has, set the flag to indicate that sampling should begin.
;
in al, dx ; sample
port
test al, 80h ; card detected?
jz ciao ; nope - later!
mov word ptr
DGROUP:_start, 1 ; card’s there,
; start reading it
jmp saveit
;
doit:
in al, dx ; Read the port
test al, 80h ; card detect bit set?
jz disable ; if not,
quit
;
; Data is still valid; get buffer pointer and save the data
;
saveit:
mov bx,word ptr DGROUP:_bufp ; get addr. to write
mov byte ptr [bx],al ; save
sampled value
inc word ptr DGROUP:_bufp ; and bump the ptr
inc word ptr
DGROUP:_nsamp ; update sample count
jmp ciao ; and skeedaddle
disable:
mov
word ptr DGROUP:_enab,0 ; card no longer
; detected - disable
; sampling
ciao:
pop di
pop si
pop ds
pop dx
pop bx
pop ax
iret
_shand endp
_TEXT ends
_DATA segment word public
‘DATA’
;s@ label byte
_DATA ends
extrn _nsamp:word
extrn _port:word
extrn _bufp:word
extrn _enab:word
extrn _start:word
_TEXT segment byte public
‘CODE’
extrn _inportb:near
_TEXT ends
public _shand
end
=== END
OF SUMMARY ===
Add A Comment