Ipsa scientia potestas est

Over the last few days I have been working hard on an application to easily interface with my MSR206. Essentially the idea is to create a cross platform tool which enables the user to send commands, read/write from/to the device. I am codifying the programmers manual. The language of choice on this go-around is Perl, using Device::SerialPort.

My initial development berth was MacOS X on a Macbook Pro, using a Keyspan USA 19-QW. Unfortunately there is an undocumented bug with port->write() under OS X at this time, so I had to switch over to Linux on standard hardware with a legitimate RS232 port.

For your enjoyment, here is the help output of the app thus far:

[evan@serv2 ~]$ ./dmsr206.pl 

dmsr206.pl v0.1a - Evan Brewer 

        - Tool for communicating with a Unitech MSR206-3HL via RS-232.
        - Conforms to ISO/IEC 7811-6
        - NOTE: ALL OPTIONS MUTUALLY EXCLUSIVE EXCEPT --device

        - NOTE: Busted under MacOS X (bug Device::SerialPort author)

Usage: ./dmsr206.pl [command] --device=

Options:
        --device=       Specify device.  Mandatory.
        --debug                 Put ./dmsr206.pl into debug mode.
        * --reset               Reset the MSR206 to an initial state.
        --all_led_off           Turn off all LEDs.
        --all_led_on            Turn on all LEDs.
        --red_led_on            Turn on red LED.
        --green_led_on          Turn on green LED.
        --yellow_led_on         Turn on yellow LED.
        --read_raw_data         Read swipe without ASCII decode.
        --read                  Read swiped card and return data with ASCII decode.
        --set_high_co           Set High-Co.
        --set_low_co            Set Low-Co.
        * --write_raw_data      Write data to swiped card.
        * --write               Write data block to swiped card.
        * --sensor_test         Verify card sensing circuit,
                                        Either swipe, or send reset.
        * --ram_test            Test onboard RAM.
        * --set_leading_zero=XX Set leading zero pad value before card data starts.
                                        [pad] * 25.4 / BPI (75 or 210)mm
                                        Default: [3D] or [16]
                                        TK1 & TK3: [3D] means leading zero=61
                                        TK2: [16] means leading zero=22
        * --check_leading_zero  Query for current pad value.
        * --erase_tracks=
Erase swiped track(s)
                                        [00000000]: Track 1 only
                                        [00000010]: Track 2 only
                                        [00000100]: Track 3 only
                                        [00000011]: Track 1 and 2
                                        [00000101]: Track 1 and 3
                                        [00000110]: Track 2 and 3
                                        [00000111]: Track 1, 2 and 3
        * --erase_card          Erase card (same as --erase_tracks=00000111)
        * --select_bpi=        Select density of TK2
                                        [D2]: TK2 BPI=210 [4B]: TK2 BPI=75
                                        high=210, low=75
        * --get_device_model    Retrieve model.
        * --get_firmware_version        Retrieve firmware revision.
        * --set_bpc=               Set bit per character of every track.
        * --get_co_status               Retrieve coercivity status.

        * INDICATES NOT IMPLEMENTED YET

Examp: ./dmsr206.pl --read  --device=/dev/ttyS0
         - Read from swiped card on COM1 under Linux and write to STDOUT

Examp: ./dmsr206.pl --reset --device=/dev/cu.KeySerial1
         - Reset MSR206 on Keyspan USA-19 under MacOS X

The text is a bit small, but I wanted to ensure that it looked right on the blog. As you can see, the application is command-line, and is passed arguments to control the device.

Next I’ll give a demo of how the application might be used:

$ ./dmsr206.pl –device=/dev/ttyS0 –set_high_co

$ ./dmsr206.pl –device=/dev/ttyS0 –read_raw_device > stripe.out

Through the magic of Device::SerialPort, I am able to talk to the MSR206, set the coercivity to high, and run a card for reading raw output. The MSR spits back formatted data to STDOUT and we capture that output to the file stripe.out.

You might ask yourself, “Well if we’re reading raw output, then why do you say it is formatted?” The answer is relatively simple. After hexdump’ing the output , the only way you’re going to know where the data on Track[123] begins/ends, you’ll need some kind of delimeter, or sentinel, as the terminology goes in the magstripe world. The MSR outputs begin/end sentinels inside the output so that one may discern the boundaries as well as whatever data may be laying in Track[123].

I am in the process of ensuring clean output, but from the results so far, the “–read” and “–read_raw_data” logic seems to be working pretty well.

I originally had some concerns that multiple passes against a single card would result in inconsistent data, so I used the following technique to attempt to ascertain consistency:

$ diff -u <(hexdump stripe.pass.1) <(hexdump stripe.pass.2)

Thankfully the passes are mostly identical, at least up until the end sentinel produced by the MSR. Periodically, after the end sentinel there is junk data. We really don’t care about the junk data because that is what for are the sentinels. *grin*

The next bit of work is to ensure that the “–reset” command works as expected. Right now it simply sends an \x73\x61\r, without then following up with the appropriate \x73\x65\r, read for response, and send another \x73\x61\r.

I will probably work on both the “–reset” as well as attempting beginning another tool to break apart the MSR formatting and reveal the raw track data.

More to come.