To take the unit apart there is 1 screw under the circular sticker on the back. Once the screw is removed simply (gently) pry the unit apart. Here are some pictures I took of the internals:

GPS Receiver

Antenna & PIC18F

In the first image you can see the GPS receiver. It’s a Ublox LEA-5S. I did some searching on-line and the only place I found a price listed for them had them listed at $99USD. I’m sure it’s much cheaper in bulk, or to order direct from Asia vs. NA Distributors, but still pretty good.

Next we have the microcontroller. It’s a PIC-18F. Per-unit price is somewhere in the area of $5. In addition to this, the units came with a mini-USB cable, car lighter adaptor w/ USB A type connector (making it useful for charging cell phones as well as this unit), 2GB uSD card, and the battery is a Sanyo Li 3.7V 1150mAh battery. I would have never paid $120USD for this thing, but at $15 it’s an absolute steal!

Cheers!

Here is the Arduino sketch code to read the data from an HID RFID Card. FYI: I know it looks stupid to use an array of bytes to read binary data, but since the boolean type is a byte in size (according to the arduino.cc reference site) it made more sense to use bytes and not have to switch from ‘true/false’ to ’1/0′ when trying to print to a debugging console or to do math with.

// Test code for HID Prox reader with clock/data output
// Code by Paul Lariviere – Jan 2011
//
// Card Present should be wired to pin 13
// Clock should be wired to pin 2
// Data should be wired to pin 12

int cardPresentPin = 13;
int clockPin = 2;
int dataPin = 12;
volatile int count = 0;
volatile byte data[200];

void setup()
{
pinMode(cardPresentPin, INPUT);
pinMode(dataPin, INPUT);
pinMode(clockPin, INPUT);
attachInterrupt(1, readBit, RISING);
Serial.begin(9600);
for (int a = 0; a < 200; a++)
{
data[a] = 0;
}
}

void loop()
{
if (digitalRead(cardPresentPin) == LOW)
{
//Serial.println("interrupts enabled");
interrupts();
}
else
{
noInterrupts();
if (count != 0)
{
Serial.println("READ COMPLETE!");
for (int a = 0; a <200; a++)
{
Serial.print(data[a]);
}
count = 0;
}
}
}

void readBit()
{
//Serial.println("reading bit");
if (digitalRead(dataPin) == HIGH)
{
data[count] = 0;
}
else
{
data[count] = 1;
}
count++;
}

The code works by attaching an interrupt to the Clock line that will trigger the readBit function, which will read a bit from the data line and store the result in an array at each time interval. If you want to see why this works, you can check out the HID Reader documentation to see a protocol timing chart and it becomes immediately obvious what is going on.

Once a card is placed in range of the reader, the reader changes the state of the Card Present pin. This code will enable interrupts as soon as this signal is detected. Once interrupts are enabled, a clock signal triggers a bit-read event until the card is read.

So this code will read the first 200 bits from the data line. You can check HID’s documentation to see exactly how many bits it spits out, but it’s more than 200, I simply stopped reading early. IIRC the final output is the same format as track2 data on a magstripe, so if you want to read the whole thing you can check the HID documentation to see how many bits the entire read ends up being.

Once we have the data, we then need to convert the raw data to a final card number. This part was particularly bothersome to figure out because I had a really hard time with HID’s documentation of the procedure. It’s probably just because I’m slow, but it took me quite a few tries and several reads of the documentation to decode the card data. I will post the detailled procedure I used in case anybody else find the HID docs to be a bit confusing.

Here is a sample of output that I received when reading an unused test card:

0000000000000000000000000
1101000001000010000100001
0000100001000010110110101
0000101000100001100101101
0000101101111111110000000
0000000000000000000000000
0000000000000000000000000
0000000000000000000000000

The output is laid out as 25 bits per line. The protocol specification says that the reader sends 25 leading 0′s and a whole bunch of trailing 0′s after the actual useful card data. Here is the above output with the additional rows of 0s removed:

1101000001000010000100001
0000100001000010110110101
0000101000100001100101101
0000101101111111110000000

Here is the info given from the card (# printed along the edge of the HID card):
card #: 35779 = HEX: 8BC3 = BIN: 1000 1011 1100 0011
This binary pattern is what we’re ultimately looking for in our end result

This is the raw data decoded assuming 5-bit chunks with format: MSB X X LSB PARITY
stripping off the parity and converting to hex we get:
B0000000650213606F
or in binary with parity bits removed:
B – 0000 0000 0000 0000 0000 0000 0000 0110 1010 0000 0100 1000 1100 0110 0000 0110 – F

B and F are the start/end sentinels so we don’t need them

Here’s the tricky part. 1: the bits are reversed (msb..lsb) and 2: it looks like 4bit hex but it’s actually 3bit octal with an extra 0 for padding on the right hand side (so the true format is MSB X LSB PAD). Inverting the bits and dropping the 0 pad we are left with:

110 101 000 010 001 011 110 000 110

Now, we start from the right and take 26 bits (results in simply dropping the leading 1 in this case) and we’re left with:
10 101 000 010 001 011 110 000 110
p……………………………………………..p

The first and last bits of this 26bit remainder are parity bits. Toss them. Result:
0 101 000 010 001 011 110 000 11

Re-arrange this result into 4bit chunks and covert to hex:

…5……0………8……B……C…..3
0101 0000 1000 1011 1100 0011
| facility # |…….card number…….|

The card number portion matches exactly our “known” card number from above. For a complete implementation these mathematical operations just need to be converted to code. I never ended up finishing this project b/c we decided to use a Rabbit micro. for our access control application due to the performance and price ($32 ~ the same price as an Arduino but with built-in Ethernet + web server, etc.)

When implementing the decoding into an Arduino sketch it would be a good idea to perform parity checks instead of just tossing the parity bits away as I described above. If anybody ends up implementing some Arduino code to finish the functionality and sends me a msg I will post a link to it here.

Happy Making!

My part in this is obviously VERY limited due to my current situation, but I was to be responsible for coding the base unit as well as the touchscreen HMI. Since I had already ordered the 4dsystems uLCD-32PT(GFX) module from sparkfun I decided to play with it and load sample code and start working on the HMI whenever I have time. I got sample code loaded and everything was cool until I tried to use the SD card. As soon as I tried to use it I was getting “Disk not mounted” and “unable to mount” or “Card OUT” depending on which sample program I ran. My card was 4gb, but was formatted for fat16 anyway and should have worked. As I pulled the card in and out while running the USDTEST sample program I noticed that the text on the screen quickly flickered to “Card IN” and back. I found that if I held the card @ just the right spot it would stay @ card IN. The problem was that I cheaped out and bought the least expensive piece of trash uSD card I could possibly find. It seems that the pads on it did not line up properly with the pins in the display module. As soon as I took a SanDisk uSD card it worked like a charm. I just wanted to post this b/c there seem to be several ppl. on the forums complaining that their SD cards don’t work despite being properly formatted. I tried to post to the 4dsystems forum but they require not only email validation, but subsequent manual approval of the account. I’m not exactly what you’d call a patient person, so hopefully when somebody searches for solutions ot this problem they’ll stumble upon this. That’s all for now, but I’ll be sure to post updates when I get cool touchscreen stuffs working

Cheers!

NOTE: Those of you interested in PAL: Go to my original blog post (link above) and look at the code linked. You will see a crapload of DEFINE blocks that are enclosed in comments. One set of comments contains a set of variables used for PAL, the other for NTSC. IIRC you can simply swap the values for PAL to replace the NTSC values in the library and it should work just fine. I think a few little things change, like # of chars that will fit on the screen, so you might have to play with that a bit, but it should be pretty straightforward.

Cheers!

Some of the more major things that I’ve been involved in lately (which I will post about seperately) include:

1. Delivering the first ThinkHaus intro to Arduino course
2. Writing working code, and figuring out how to decode the data from a HID RFID reader model: ProxPoint Plus 6800 w/ clock & data output
3. Started designing a door controller for RFID access to ThinkHaus. Design is being carried out using a Rabbit RCM5600W microcontroller with an onboard web-server. The plan is to have a web-based admin console to control stand-alone door controllers and, eventually, to create a Master application that can act as one central administration point for a network of nodes. I’m also going to be rigging up an SD Card for logging and modifying the Rabbit FAT/SD libraries to allow me to use them with the 5000Core.
4. Tomorrow I’m heading to my buddy’s place to rig his coffee maker up to a rabbit controller so that he can start it from work, or set it to turn on before his alarm goes off. Will post pics/code of the build.
5. I’m sure I’ll think of stuff I forgot later and just post as it comes to me..

That’s all the time I have for now. Stay tuned for updated detailed posts about each of the above. I plan to release the slides I used to teach my course, the source code for Arduino to interface w/ the HID RFID reader and the rabbit code/schematics for our door controller once it’s done.

Cheers!

Cheers!

Cheers!

As you can see, NTSC/PAL and VGA output is pretty neat when combined with some microcontrollers. This can allow for video displays of sensor values, control of objects with PS2 keyboards/mice and audio to all be EASILY added to projects.

How it works:
The dev-board has 2 processors on it. The AVR Atmega328P and the Parallax Propeller. The two processors are connected via I2C and the Atmel acts as a master to send commands to the Propeller slave. The Propeller takes care of all of the heavy lifting when it comes to graphics, keyboard/mouse input and audio. There is a PIC version of this kit available as well, but being that the Atmel version comes with an Arduino bootloader and supporting libraries I couldn’t resist getting it over the PIC.

Review:
The only gripe I had about this product was that it took a heck of a long time for the company to ship when it had an “in stock” status. As you can probably tell by some of my previous posts, I was starting to get a bit impatient That being said, I’m not sure of the reason for the delay but it’s possible that some slight modifications were made to the dev. board. For example: I noticed that in the documentation images there is no heatsink on the regulators whereas mine both have one. Either way the wait was definitely worth it.

The user manual seems to have been written by the guy who designed the dev-board himself and it is very casual. While there are a few spelling and grammatical errors here and there, it’s not enough to be annoying and you can still very clearly tell what he means to say. I’m only ~ page 60 of ~300 so far, but from what I can see the information presented is easy to understand and thorough. The author explains VGA and NTSC in pretty good depth and also provides links to external supplemental resources. Overall I’d say this is a very well put-together product and I’m looking forward to finishing the manual and starting to create some of my own applications for it.

Another advantage (at least on the AVR model, not sure about the PIC) is that the headers on the board share a similar footprint to the Arduino, allowing compatibility with some prototyping shields/etc. The physical footprint is similar, but the pin-outs are different. The bottom row of IO are for the ATMega328P while the top row contains 8 IO from the Propeller board. Both chips can be programmed via serial and the target is selected by toggling a switch. There is also an ISP header for programming if you want to blow away the bootloader. Being that the introductory price of these kits are only $60 I’d certainly recommend jumping on one before the price goes up, because it’s a pretty good deal IMO.

The packaging from the manufacturer was excellent, each dev kit was wrapped in an anti-static bag, in bubble-wrap, inside a plastic case surrounded by foam chips. I have included pics of the unpacking at the bottom of this post.

I’ll post more when I get a project completed. I just wanted to put a quick update up since my most recent posts haven’t really had much “substance” lately.

Cheers!

Pics:

2 free LEDs... LOL

Chameleon Dev Kit

In other news, I got a quote back on those VGA displays from Kopin… and they’re pretty much out of their minds. I fully understand that companies charge more for a quantity of 1 than they do of 1000, but when I saw a fully finished product that made use of TWO Kopin VGA displays sell in its entirety for under $350, I figured 50% of that would be about what I’d pay for the display, possibly a bit less since I figured this other company would charge extra for all of the other parts/components as well as R&D. To my dismay, ordering 1 kopin display directly from them would cost me over $400 (400+taxes+duties to be exact), which is MORE than purchasing a finished product containing TWO of these things elsewhere. What was even more interesting was that the website clearly lists the driver IC in both a TQFP and BGA package and in the quote I was sent, I was informed that it was ONLY available in BGA. Long story short, I’ve decided to order the finished product and rip it apart. Not only will it save me TONS on the cost but it will also provide me with a PCB that I can work with since I’ve never hand-fabbed and soldered a board for a BGA chip before.

Sorry for so much “nothing” for so long, I hope to have some more “awesome” posted shortly

Cheers!