The first thing that struck me was the burnt flux on the main chip:

Then I noticed staining on around the caps too, nothing that affects the functionality of the unit but it left me feeling disappointed. This arduino cost me £57 + shipping + a new ethernet shield to use with it (which is incidentally, absolutely perfectly manufactured and really shows up the mega). My board also had sharp bits on but I filed them off. I paid a premium price to get what I thought was a premium quality product, clearly I was wrong and will think twice before buying any official arduino hardware again.

And don’t even get me started on releasing the boards before there was linux support. At first I thought I had faulty hardware after seeing it and then it not working.

In this post I intend to briefly outline things I’ve tried that can make it work at least a bit…

Hardware

The main improvement, for me, of this new arduino over the old mega is the double memory capacity which allows me to grow a bit further after the duemilanove. Most noticeable on arrival is the new packaging which is a nice touch and makes the product feel like a commercial product rather than some underground toy.

However it’s not all good, the quality of production of this board seems to have dropped slightly, it having a significant amount of flux on the chip, not a major issue, I just like things to be perfect!

Software

This is where all hell breaks loose. The arduino mega 2560 and arduino uno require the new version 0020 of the IDE to work correctly, this is not yet available on linux due to rxtx problems, when I ordered I stupidly assumed that there would be the same software support that had always been there but sadly not, so I tried a few things to try and make it work, with varying amounts of success:

Run the IDE under Windows XP in a virtual machine

While I could put up with this for a week or two it’s not ideal..and proved far from reliable.

I duly downloaded and installed the windows version of arduino 0020, I already have a virtual machine set up with XP and usb set up, so I piped through the usb port for the arduino, it was detected by windows and appeared to install correctly however when attempting to upload the blink sketch (which compiles fine) I get errors from avrdude:

avrdude: stk500v2_recv(): checksum error
avrdude: stk500v2_recv(): checksum error
avrdude: verification error, first mismatch at byte 0x0268
0x68 != 0xb1
avrdude: verification error; content mismatch

After retrying sometimes I was able to upload a sketch, but not reliably, sometimes it just hanging on upload. At this point I didn’t really know what to do,  so I tried it on a real windows computer and it worked fine…but that is not a workable solution for me so I tried a more radical approach:

Modify the Arduino 0019 IDE to work

I did not have high hopes here as there is obviously a reason if the arduino team are having issues with 0020 on linux. However I had limited success.

I took the hardware/arduino/boards.txt file from the new windows arduino 0020 ide and pasted it into the corresponding place in the 0019 IDE on linux, the arduino mega 2560 (and uno) now appear in the boards menu. All good so far but in removing the ftdi chip the arduino moved its default location moving from /dev/ttyUSB0 to /dev/ttyACM0, to compenste for this I made a symlink between the locations sudo ln -s /dev/ttyACM0 /dev/ttyUSB0 after inserting the arduino usb lead into the computer.

Now when starting the ide there is a delay of several seconds longer than usual with no errors shown, sketches can be opened and compiled for the mega 2560 but everytime the tools menu is accessed there is the same hanging of the program for several seconds while the serial ports are searched. Despite these problems sketches can be uploaded most of the time, others the arduino just hangs…

Edit: Since writing this post I’ve noticed that there were 5 instances of avrdude running left over from my messing about collectively maxing out my quad core processor so there are definitely  still issues to be resolved!

That’s as far as I got…hoping for a better solution soon…

• Migrate the library to use the new bundled string library rather than the WString library (mostly done)
• Tidy up the code
• Add functions for onconnect, onmessage and allow sending of strings at a time determined by the Arduino, not just in response to a message from the client.
• Update the library to allow recent browsers to connect. Currently the library supports the version 75 handshake protocol but most browsers have now moved to the more recent 76 protocol..

The project is available to download on Github currently this will only work with versions of Google chrome before 6.0.414.0 but this will hopefully change soon as the handshake is updated.

Guerilla Knitting

Around Newcastle for the past few days knitting has been appearing attached to railings and signs, this was organised as part of the Newcastle Science week and really does look pretty cool, I especially liked this example above outside the Discovery Museum and the one below in the Centre for Life. This seems to be part of a larger movement, known as Guerilla Knitting which aims to bring a smile to peoples faces by placing art in somewhere unusual (from here – the most sensible explanation I can find).

Sugru

Sugru has rapidly become a bit of a cult material recently and having been publicised by mentions in Make and Wired is now very difficult to get hold of. It seemed to be just as popular in the flesh as online and the stall always seemed busy throughout the day. Sugru is an unusual material, much like a grown up version of play dough which hardens into a grippy silicone rubber when left to set. It’s also self adhesive so it can be used to fix and modify items as far as your imagination allows. I had the chance to meet two of the people behind it – Jane (it’s creator) and James(? if that’s wrong I’m sorry I really should remember after specifically asking!) :

Rubot II

The Rubot II is a robot which can solve rubick’s cubes in a maximum of 50s. It was probably the most impressive example of robotics on show and I found it particularly interesting having worked on computer vision systems for my MSc. thesis. Having said all that I felt it a little lacking compared to many other stalls as it’s a bit of a one trick pony and I think I like things with more of a reason for being.

.: oomlout :.

Oomlout is a name I’ve mentioned several times on this blog and is my preferred retailer of arduino type things, they had all the usual things on show but what particularly caught my attention were some juicy looking robot kits not yet for sale:

Another thing they had was the twypewriter which uses and arduino to receive and then printout tweets, however along with many other network connected devices on show, it was having troubles with the wifi network! This the whole stall captured in this rather unflattering shot:

My delight for free stuff was also indulged and I got a free keyring, something I’ve wanted since I saw photos of them at the 2009 Maker Faire.

Mitch Altman

Well known hardware hacker and creator of the TV-B-Gone Mitch Altman gave a couple of talks (which I managed to miss because I was distracted talking to other people) and could be seen hanging around the hardware hacking workshop area where people were also trying out these cool looking self hypnosis glasses:

BBC

I wasn’t aware that the bbc did cool stuff like this but they were exhibiting a number of ‘inventions’ from thier labs. Including a camera system which takes high resolution images with a very deep depth of field and then allows adjustment of the depth of field afterwards. A physical remote control with echoes of retro tv remotes where the controller was wired to the tv and allowed users to more easily take control of the tv (I’m really not sure of the point…). More interesting was a system designed to allow families to choose what to watch democratically, based on the game Guess Who, however here players would flip down all the tv shows they didn’t wish to watch and the system would generate a playlist of shows which were liked by all:

Bubblino

Yet another twitter and arduino powered device which simply blows bubbles when tweeted to/about:

Also on the same stall a system for monitoring the running of the Mersey Ferries using AIS positioning (which seems to take inspiration from Andy Stamford Clark’s twittering ferries):

Musical Tesla Coils

A common feature of maker and science faires across the world are singing tesla coils in this case designed by Karim Ladha. They were quite impressive, allowing music to be played from a keyboard or guitar which modulates the output of the coils and makes a very loud (and rapidly annoying noise):

Curiosity Collective

A group of guys from Ipswich, probably best known for walking to the Faire via Amsterdam (athough those who were doing that currently hadn’t arrived when I spoke to them!). They had some cool map visualisations and also an experiment into how accurately people can draw a map of the UK from memory.

mbed

The mbed microcontroller board with an ARM chip looks very attractive to me. I had a nice explanation of it’s finer points from one of the guys there but I’m still slightly unhappy about relying on an online compiler for some hardware to function, in a similar way to me not having bought a PS3 due to its need to be online. We’ll wait and see, if I have some spare cash to splash I might get one soon.

Other People

I also met people from openenergymeter, sonodrome and hackable devices, all of which had some cool things on display. Hackable devices had some cool open source devices on show like the Neo Freerunner, makerbot and other bits and pieces sadly we couldn’t play with them. They also suffered after their stall collapsed half way through the morning.

All in all a very enjoyable day talking to some very nice people and learning lots. I also had chance to revisit some favourite Newcastle haunts including the Baltic and the Side gallery both of which had good exhibitions. I got an amazing bargain from the Oxfam bookshop: A new hardback copy of “The C++ Programming Language” for £3.99 rather than the usual £40-50. My legs now ache terribly from carrying it around all day in addition to my camera, lenses and laptop!

I have mentioned in previous posts that I use various scripts and sensors to feed data into the open source MQTT broker mosquitto. Currently all data is posted to pachube, rather than everything being online I decided I wanted some physical feedback. Having made an impulse buy of two vintage Ferranti ammeters using these to display some of my data seemed like obvious answer! The code on the arduino basically just displays a number passed by MQTT on the meter and therefore could be applied to any measurement one cared to choose.

The basic idea of this system is to monitor the current internet speed usage and display it on the ammeter. The system is based around an arduino with ethernet shield which acts as an MQTT client, this subscribes to the downstream bandwidth topic on my MQTT broker, receives the messages and changes the level of a PWM output pin on the arduino which causes the meter to show the appropriate level. The meter displays the current through a resistor which is varied by the PWM signal from the arduino. The reading on the meter corresponds to the current internet speed usage as a percentage of the overall theoretical available bandwidth.

The Arduino Code

As this is quite well commented I won’t go through it, but it serves as a good example of how to receive MQTT messages using an arduino:

#include <Ethernet.h>
#include <PubSubClient.h>

//Setup network connection
byte mac[] = {  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { <arduino ip> };
byte subnet[] = {<subnet>};
byte gateway[] = {<router ip>};

//MQTT Broker
byte server[] = {<mqtt broker (mosquitto/RSMB)>};
int port = 1883;
//Meter output spin
int meterPin = 9;

//Set initial bandwidth
float out = 0;

//MQTT client setup
PubSubClient client(server, port, callback);

//Add callback for when a message is recieved
//
// Takes bandwidth as 4 digit number e.g 44 = 0044
void callback(char* topic, byte* payload,int length) {
  //reset value
  out=0;

  //convert receieved byte array into number
  for(int i=0;i<4;i++)
  {
    //get the byte
    byte ardValue = payload[i];
    //multiply it by 1/10/100 or 1000
    double tens = pow(10,(3-i));
    //convert the byte to either 1/10/100/1000
    float ardOut = tens * (ardValue-48);
    //add to total output
    out +=ardOut;
  }

  //scale number between 0-4000 to 0-255 for output
  out = map(out, 0, 4000, 0, 255);

  //print result to serial port for debugging
  Serial.println(out);

  //write output to meter
  analogWrite(meterPin, out);
}

//setup method
void setup()
{
  //start ethernet connection
  Ethernet.begin(mac, ip, gateway, subnet);

  //start serial connection for debugging
  Serial.begin(9600);

  //connect to MQTT Broker
  client.connect("arduino");

  //Subscribe to topic bandDown
  client.subscribe("bandDown");
}

//main loop
void loop()
{
  //Tell the MQTT broker we're still here
  client.loop();
}

The PHP script that provides the bandwidth data resides on my sheevaplug and queries my router for an XML file with the appropriate details, I talked about this in a previous post.

General Component Retailers

These are the retailers I most commonly order parts from and like, there are many others who may also be good but these are my favourites, as they stock the basics they’re used more than any other category here.

Bitsbox

Bitsbox is a small retailer with a large following, it sells mainly simple components: capacitors, resistors, basic connectors, basic tools all for very reasonable prices when ordering in small quantities, something which is not common among many bigger suppliers. Also standard postage is only 1.50 on any order. I’ve bought here many times and always had a great experience, quick dispatch and good communication.

Farnell

Farnell is about the most furthest away from Bitsbox it’s possible to get in size and product selection,  it stocks hundreds of thousands, maybe millions of products from the mundane basics to the high end exotica and offers free next day delivery on any order. If you need something, almost anything in electronics quickly this is where to go. They are also the only retailer I’ve found in the UK which stock Texas Instruments components. Service is another area in which farnell is great. Prices can be high on some items but not unreasonable, my recent Agilent multimeter was 20% cheaper than any other UK retailer. Beware of items marked in stock in US which attract a 15 pound postage fee.

A point worthy of note is that if you want you can pick up orders from the trade counter at their international distribution centre in Leeds, West Yorkshire, something I’ve done a few times. You have to phone to order this way but the order can be collected after 2hrs and is within walking distance of Leeds Station and also is easy to drive to/park at. This makes them my 2nd favourite retailer on this list after NewIT (below).

Rapid Electronics

Rapid are a retailer smaller than Farnell but still quite large, they stock some products which Farnell do not but the catch is that orders under 35 pounds are changed 5 pounds postage. Redeeming factors are the postage is quick and service is generally good.

eBay

If you wish to buy low quality components in bulk then eBay is the place, often from China but usually reliable but usually cheap enough to risk it, especially with the protection provided by Paypal.

Maplin

Maplin only deserve a mention as they are the last high street retailer which sells any kind of electronic components, otherwise they provide inconsistent service, have sometimes stupid staff and charge lots for bad quality products. But if you need some wire quick then it’s the only option really! A sad summary to give considering it was maplin and tandy (radioshack) which have been with me since my childhood electronics fad which never quite went away.

Mouser

Mouser not based in the UK but from my experience have proved the best retailer in the IS to order from if you have to, I ordered 2 panavice bits which are hard to find in the UK and they arrived within 2 days. Amazing, and delivery on orders over 50 pounds and they sort out the VAT in advance so you don’t get caught out later. These guys are amazing. They also stock some cool bits like beagle boards.

Arduino Etc…

A big factor in reigniting my interest in electronics, which had faded since I discovered computers, was micro controllers such as the arduino, these are quite easy to come by in the UK but I have two preferred retailers:

.:oomlout:.

Oomlout are another small company based in Leeds, they stock the Arduino and associated accessories at reasonable prices, including quite a few nice bits of their own making: the arduino prototyping board is a simple piece of laser cut acrylic with holes to bolt the arduino and a small breadboard to fix next to it. They also stock a small range of products designed by Adafruit (which would be on this list if I was in the US!) which is nice as it saves shipping from the US. Service is, as with most small specialist retailers, exemplary. I’ve made a few queries both for information and to resolve a problem and both were dealt with quickly. My definite first choice for Arduino related stuff. Oh and shipping is cheap and quick too.

Cool Components

I have mixed feelings about Cool Components, they sell a much larger range of products than oomlout, offering more advanced microcontrollers and accessories, they’re almost the Sparkfun of the UK (and they do stock some Sparkfun products). However I feel they seem expensive and VAT is not included in the displayed prices which I feel can be slightly misleading (even though it is stated). I have however bought from them when they had what I wanted and the service they provided was good.

Seeed Studio

Seeed Studio are not based in the UK but in Hong Kong, however they ship to the UK for cheap prices and offer a lot of components at very cheap prices, like sparkfun style RF transceiver for $4 and the arduino clone Seeeduino. More recently they have started to retail open source test equipment which is attracting quite a lot of interest.

Sheevaplugs

If you’ve read my blog before you may know I’m a fan of the sheevaplug. I’ve had mine several months now but when I first found the product I knew of no retailer in the UK, at around the same time New IT was started acting as a European distributor, saving me the hassle of high prices and long waits of ordering from GlobalScale in the US.

NewIT

New IT only currently sell Sheevaplugs, Guruplugs and the OpenRD and associated accessories and offer free shipping on all items. Despite the small product range shopping at New IT was possibly the best online shopping experience I’ve ever had, the online shop is just a typical shop but after ordering I received personal emails on order status and a check to see if it had arrived and if I needed any further help. In this day and age, nothing short of amazing.

The Hardware

Recently I’ve acquired a Home Easy HE217 remote light switch which consists of a unit placed between the light bulb and ceiling rose and a wireless switch to switch the light on and off from anywhere within about 10m. I purchased this with some form of hackery in mind but this is the first real attempt to do anything useful outside of the functionality of the supplied package. The system uses RF at 433MHz and a simple authentication protocol, which is conveniently documented at the Home Easy Hacking Wiki.

433MHz is a common frequency used by radio controlled devices such as remote switches, garage doors and car remote controls and transmitters and receivers are readily available for very little money (around $5). These can be used for many uses especially in combination with an arduino, following on from the work documented on the Home Easy Hacking Wiki an arduino library has been produced (available here). This allows the arduino to control the light switch in the same way as the provided Home Easy light switch.

The RF transmitter was then simply connected to the arduino to allow the light switch to be controlled using the arduino.

The software

The software aspect of this project consists of my previous processing sketch which receives button presses from the chronos watch, to this I added functionality so that every time a button press is received a serial character is sent to the arduino in this case H for on and L for off.

On the arduino a sketch is used that reads the serial input and when H or L is received it send an on or off message using the home easy arduino library thus switching the light. The observant among you will have noticed that this is based on the arduino physical pixel example!

The system works even if the watch is taken out of transmit mode and then restarted.

The code can be viewed below.

In action

The code

The processing sketch chronoslight.pde

The arduino sketch: chronosHE.pde

Recently my Texas Instruments ez430 Chronos watch arrived, I preordered it the day I read about it on engadget back in November 2009, so it was nice to receive it after all this time. As a dedicated Linux user I found it disappointing that there was little in the way of Linux support provided by TI, however this was not unexpected and a linux application is currently being developed, although progress seems to be somewhat slow. However in the last week breakthroughs have been made, uguryildiz in a post on the TI forum revealed the protocol used to request data from the acceleration sensors and also for setting of the time allowing custom applications to be built using this data on Linux or any other operating system able to use usb serial.

Example code in python was also posted here, basically the protocol for getting the accelerometer data is very simple:

• After connecting the RF USB dongle supplied with the watch and putthe watch into ACC transmit mode and connect to the serial port /dev/ACM0 (on linux) with baud of 115200
• Send the hex string: 0xFF 0×07 0×03 to open a connection with the watch, it should reply 0xFF 0×06 0×03 to confirm a connection has been made
• Accelerometer data can then be requested by sending 0xFF, 0×08, 0×07, 0×00, 0×00, 0×00, 0×00
• The watch will then return seven bytes back in the form ff 06 07 tt xx yy zz where the last three bytes are the accelerometer values.

As a simple experiment I used the afore mentioned python code to get data from the watch and then combined this with a graphing gui example kindly posted by Eli Bendersky to make an application which uses matplotlib produce a live graph of the data (currently only one axis at a time).

My code can be downloaded here: chronos_graph.py

It should be noted that this code is very much hacked together, I am not a python coder and have never written anything in python before in my life, but it should work.

I am currently working on trying to get this working with processing and arduino, however serial communication from processing with the watch is proving troublesome so I reverted to python for this example.

In this post I will describe a method for the capture of video frames from a webcam using OpenCV, the subsequent processing required to convert to an 8×8 monochrome image and the process of sending the data via serial to arduino using libserial which is linux specific. Example source code is included at the end.

Having previously used a Logitech Quickcam Fusion with windows and OpenCV I started out on this project assuming it would work in linux, however the camera isn’t fully supported by Linux due to the specific chipset used so I replaced my webcam and found the Microsoft Lifecam Cinema Webcam to be fully linux compatible and the highest quality webcam currently available at a sensible price (currently ~£45 on Amazon) and has proved to work very well in all respects producing very high quality images (for a webcam).

Video Capture and Processing

The rest of this post assumes that OpenCV has been correctly installed and is known to the compiler and will concentrate on the main functions required to perform the capture and image processing.

OpenCV represents video streams as CvCapture objects, andOpenCV images such as video frames as IPL images, a standard type defined by Intel but basically an encapsulated BGR matrix of the pixels. So initially I define the variables which will hold the capture stream and the images required:

CvCapture * pCapture; //new OpenCV capture stream
IplImage * pVideoFrame; //new OpenCV image
IplImage * pVideoFrameBW;      //new OpenCV image for colour conversion

A video stream from a camera, assuming that the camera is correctly installed in the guess operating system, can be initialised in one line:

pCapture = cvCaptureFromCAM(0); //choose camera for capture

where the parameter is the capture device, if you only have one webcam it’s likely to be 0 otherwise you’ll need to experiment to find the correct one.

To display the image being transmitted a window can be created using the HighGUI library integrated with OpenCV:

cvNamedWindow( "video", CV_WINDOW_AUTOSIZE );

Now the main data structures have been defined we need to enter into a loop to perform the frame capture and processing. OpenCV includes a GUI library and this will be used to display the images on screen and also control behaviour of the program, in the example code extra GUI features control some parameters. To control the loop we will use the cvWaitKey(int time) function which returns -1 if no key press has been detected and the ASCII code of the character if a key is pressed within the time specified in milliseconds. Therefore the main loop will be of the form:

int key = -1;
while(key==-1)
{
capture and process
}
clean up and exit

Inside every cycle of the loop a new frame needs to be captured from the stream, this is achieved using the the cvQueryFrame(CvCapture pCapture) method:

pVideoFrame = cvQueryFrame(pCapture);

Next to reduce the number of colours in the image a threshold is needed of the image, again OpenCV includes a function to do this:

cvThreshold(pVideoFrame, pVideoFrame, thresh, 255, CV_THRESH_BINARY);

where thresh is the level to which thresholding is required, more information can be found here.

As the data required for display on a basic LED matrix is not in colour it needs to be converted to black and white, in OpenCV this works by creating an empty image of the correct colour depth and then using the cvCvtColor() function:

pVideoFrameBW=cvCreateImage(cvGetSize(pVideoFrame),8,1);
cvCvtColor(pVideoFrame, pVideoFrameBW, CV_BGR2GRAY);

As currently the LED matrix I’m working with is an 8×8 type the image needs to be scaled down considerably to fit, in my case by about 60 time, this is done in a similar way to the conversion of the colour:

/*create small image*/
IplImage* out = cvCreateImage( cvSize(pVideoFrameBW->width/60,
pVideoFrameBW->height/60), pVideoFrameBW->depth,
pVideoFrameBW->nChannels );
cvResize(pVideoFrameBW,out,CV_INTER_NN);

In order to display the image on screen at a sensible size the small image needs to be scaled back up again and then displayed:
cvResize(out,pVideoFrameBW,CV_INTER_NN);
cvShowImage( "video", pVideoFrameBW);

This produces a window which will look something like this:

Now that a small monochrome image has been formed the value of each pixel needs to be transmitted to the arduino if it is black or white. The value of a pixel can be extracted from the image using the cvGet2D() method and returns a CvScalar object containing three matrices ( for BGR respectively)  for ease I have taken just the blue values here, the two loops consider each column of pixels and store their value in p:

for(int y=0; y<8; y++)
{
for(int x=0;x<8;x++)
{
CvScalar s;
s=cvGet2D(out,y,x);
/*save pixel value (blue)*/
int p = s.val[0];
/*print value to terminal for debugging*/
printf("%i",p);
if(p==255) //if the pixel is black
{
p=1; //turn on led
}
}

Now that all processing and capture has taken place for this frame we can wait for a keypress to close the program and clean up any memory used during this iteration:

key = cvWaitKey(20);
/*release memory*/
cvReleaseImage(&pVideoFrameBW);
cvReleaseImage(&out);

Now the main while loop can be closed and final cleaning up carried out

cvReleaseImage( &pVideoFrame );
cvReleaseCapture ( &pCapture );
cvDestroyWindow( "video" );

That concludes the summary of what is required to capture images from a video stream and process it to a smaller monochrome image, next we will consider sending the data.

Serial Communication

I shall be fairly brief discussing serial communication as it’s a topic well covered in other postings such as here.

It can be achieved in linux quite simply using libSerial which allows a steam object to be created and anything which is added to the stream is forwarded to the serial port. In this system this means each pixel would be represented by a 1 or 0 depending on if the led is required to be on or off which is sent to the arduino and interpreted. In my example I used 115200 baud but had to add a delay in the loop using usleep to allow the arduino to have time to process the incoming data.

This method of sending the data is however quite inefficient as each led only requires an on or off to be sent which could consist of one bit being either 0 or 1 however this system sends data using ASCII. ASCII uses several bits per led making the communication and processing much slower than it could be, shifting the process to a stream of bits should greatly improve the framerate and will be discussed in a later post when I finish writing the code!

Arduino Code

The the arduino takes data from the serial stream and displays it on the leds and takes no other part in the processing. It uses similar code to my twitterpop project however I will get around to posting the code here soon.

Example

An example class can be found here, it shows the includes which might not normally be there but it makes things slightly clearer, you’ll need to do you’re own header file.

Having followed the instructions that came with the unit (including no mention of direct GPS functionality) and installed the provided software in windows xp I got nowhere, so I tried it on linux. The device is actually a serial device and the cable which is included is in fact not a conventional USB, cable despite having a USB-A and USB-B plug at either end, it is an FTDI usb-serial adaptor which has linux kernel support. I then found it was possible to connect to it at 4800 baud using putty or cutecom or whatever your favorite terminal happens to be and standard NMEA data is displayed.

On closer examination of the cable the USB-A end can be split apart to reveal a simple Serial to TTL converter based in the PL2302 chip, this allowed me to find drivers (available here http://www.prolific.com.tw/eng/downloads.asp?ID=24)  for all versions of windows and receive GPS data over serial in the same method as with Linux.

This means that the cable could easily be used for any 5V TTL applications required and also that the GPS unit would be ideal for interfacing with an arduino or similar system as the points for connection can be easily seen on the circuit board: