Sunday, April 29, 2012

Arduino, Android and Seeedstudio Bluetooth Bee

Introduction

In this article we examine the Seeedstudio ”Bluetooth Bee“ modules and how they can be used in a simple way in conjunction with Android devices to control the Arduino world.  Here is an example of a Bluetooth Bee:

For the curious, the hardware specifications are as follows:

  • Typical -80dBm sensitivity
  • Up to +4dBm RF transmit power
  • Fully Qualified Bluetooth V2.0+EDR 3Mbps Modulation
  • Low Power 1.8V Operation, 1.8 to 3.6V I/O
  • UART interface with programmable baud rate
  • Integrated PCB antenna.
  • XBee compatible headers

You may have noticed that the Bluetooth Bee looks similar to the Xbee-style data transceivers – and it is, in physical size and some pinouts, for example:

The neat thing with the BtB (Bluetooth Bee) is that it is compatible with Xbee sockets and Arduino shields. It is a 3.3V device and has the same pinouts for Vcc, GND, TX and RX – so an existing Xbee shield will work just fine.

In some situations you may want to use your BtB on one UART and have another for debugging or other data transport from an Arduino – which means the need for a software serial port. To do this you can get a “Bees Shield” which allows for two ‘Bee format transceivers on one board, which also has jumpers to select software serial pins for one of them. For example:

Although not the smallest, the Bees Shield proves very useful for experimenting and busy wireless data transmit/receive systems. More about the Bees Shield can be found on their product wiki.

Quick Start 

 In the past many people have told me that bluetooth connectivity has been too difficult or expensive to work with. In this article I want to make things as simple as possible, allowing you to just move forward with your ideas and projects. One very useful function is to control an Arduino-compatible board with an Android-based mobile phone that has Bluetooth connectivity. Using the BtB we can create a wireless serial text bridge between the phone and the Arduino, allowing control and data transmission between the two.

We do this by using a terminal application on the Android device – for our examples we will be using “BlueTerm” which can be downloaded from Google Play – search for “blueterm” as shown below:

In our Quick Start example, we will create a system where we can turn on or off four Arduino digital output pins from D4~D7. (If you are unsure about how to program an Arduino, please consider this short series of tutorials). The BtB is connected using the Bees shield. This is based on the demonstration sketch made available on the BtB Wiki page - we will use commands from the terminal on the Android device to control the Arduino board, which will then return back status.

Question – Which company invented Bluetooth?

As the BtB transmit and receive serial data we will have it ‘listen’ to the virtual serial port on pins 9 and 10 for incoming characters. Using a switch…case function it then makes decisions based on the incoming character. You can download the sketch from here. It is written for Arduino v23. If you were to modify this sketch for your own use, study the void loop() section to see how the incoming data is interpreted, and how data is sent back to the Android terminal using blueToothSerial.println

/* BluetoothBee Demo Code - Flowcontrol Based Implementation 2010,2011 Copyright (c) Seeed Technology Inc. All right reserved.  Author: Visweswara R Modified: John Boxall, April 2012  This demo code is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.  This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.  You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  For more details about the product please check http://www.seeedstudio.com/depot/  */
#include <NewSoftSerial.h> //Software Serial Port #define RxD 9 #define TxD 10 #define DEBUG_ENABLED 1
NewSoftSerial blueToothSerial(RxD,TxD); char incoming;
void setup() { pinMode(RxD, INPUT); pinMode(TxD, OUTPUT); setupBlueToothConnection(); pinMode(4, OUTPUT); pinMode(5, OUTPUT); pinMode(6, OUTPUT); pinMode(7, OUTPUT);
}
void setupBlueToothConnection() { blueToothSerial.begin(38400); //Set BluetoothBee BaudRate to default baud rate 38400 delay(1000); sendBlueToothCommand("\r\n+STWMOD=0\r\n"); sendBlueToothCommand("\r\n+STNA=SeeeduinoBluetooth\r\n"); sendBlueToothCommand("\r\n+STAUTO=0\r\n"); sendBlueToothCommand("\r\n+STOAUT=1\r\n"); sendBlueToothCommand("\r\n +STPIN=0000\r\n"); delay(2000); // This delay is required. sendBlueToothCommand("\r\n+INQ=1\r\n"); delay(2000); // This delay is required. }
//Checks if the response "OK" is received void CheckOK() { char a,b; while(1) { if(blueToothSerial.available()) { a = blueToothSerial.read();
if('O' == a) { // Wait for next character K. available() is required in some cases, as K is not immediately available. while(blueToothSerial.available()) { b = blueToothSerial.read(); break; } if('K' == b) { break; } } } }
while( (a = blueToothSerial.read()) != -1) { //Wait until all other response chars are received } }
void sendBlueToothCommand(char command[]) { blueToothSerial.print(command); CheckOK(); }
void loop() { // get character sent from Android device incoming=blueToothSerial.read(); // decide what to do with it switch (incoming) { case '1': digitalWrite(4, HIGH); blueToothSerial.println("pin 4 HIGH"); break;
case '2': digitalWrite(5, HIGH); blueToothSerial.println("pin 5 HIGH"); break;
case '3': digitalWrite(6, HIGH); blueToothSerial.println("pin 6 HIGH"); break;
case '4': digitalWrite(7, HIGH); blueToothSerial.println("pin 7 HIGH"); break;
case '5': digitalWrite(4, LOW); blueToothSerial.println("pin 4 LOW"); break;
case '6': digitalWrite(5, LOW); blueToothSerial.println("pin 5 LOW"); break;
case '7': digitalWrite(6, LOW); blueToothSerial.println("pin 6 LOW"); break;
case '8': digitalWrite(7, LOW); blueToothSerial.println("pin 7 LOW"); break; } delay(100); }

Before using it for the first time you will need to pair the BtB with your Android device. The PIN is set to a default of four zeros. After setting up the hardware and uploading the sketch, wait until the LEDs on the BtB blink alternately – at this point you can get a connection and start communicating. In the following video clip you can see the whole process:


Where to from here?

There are many more commands that can be set using terminal software from a PC with a Bluetooth adaptor, such as changing the PIN, device name and so on. All these are described in the BtB Wiki page along with installation instructions for various operating systems.

Once again I hope you found this article interesting and useful. The Bluetooth Bees are an inexpensive and useful method for interfacing your Arduino to other Bluetooth-compatible devices. For more information and product support, visit the Seeedstudio product pages.

Bluetooth Bees are available from Seeedstudio and their network of distributors.

Disclaimer - Bluetooth Bee products used in this article are promotional considerations made available by Seeedstudio.

In the meanwhile have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column? And join our friendly Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Arduino and FFD51 Incandescent Displays

In this article we examine another style of vintage display technology – the incandescent seven-segment digital display. We are using the FFD51 by the IEE company (data sheet.pdf) – dating back to the early 1970s. Here is a close-up of our example:

You can see the filaments for each of the segments, as well as the small coiled ‘decimal point’ filament at the top-right of the image above.  This model has pins in a typical DIP format, making use in a solderless breadboard or integration into a PCB very simple:

It operates in a similar manner to a normal light bulb – the filaments are in a vacuum, and when a current is applied the filament glows nicely. The benefit of using such as display is their brightness – they could be read in direct sunlight, as well as looking good inside.  At five volts each segment draws around 30mA. For demonstration purposes I have been running them at a lower voltage (3.5~4V), as they are old and I don’t want to accidentally burn out any of the elements. Using these with an Arduino is very easy as they segments can be driven from a 74HC595 shift register using logic from Arduino digital out pins. (If you are unfamiliar with doing so, please read chapters four and five of my tutorial series). For my first round of experimenting, a solderless breadboard was used, along with the usual Freetronics board and some shift register modules:

Although the modules are larger than a DIP 74HC595, I like to use these instead. Once you solder in the header pins they are easier to insert and remove from breadboards, have the pinouts labelled clearly, are almost impossible to physically damage, have a 100nF capacitor for smoothing and a nice blue LED indicating power is applied.

Moving forward – using four shift register modules and displays, a simple four-digit circuit can be created. Note from the datasheet that all the common pins need to be connected together to GND. Otherwise you can just connect the outputs from the shift register (Q0~Q7) directly to the display’s a~dp pins.

Question – Which company coined the term “Numitron”?

Some of you may be thinking “Oh at 30mA a pin, you’re exceeding the limits of the 74HC595!”… well yes, we are. However after several hours they still worked fine and without any heat build-up. However if you displayed all eight segments continuously there may be some issues. So take care. As mentioned earlier we ran the displays at a lower voltage (3.5~4V) and they still displayed nicely. Furthermore at the lower voltage the entire circuit including the Arduino-compatible board used less than 730mA with all segments on –  for example:

 For the non-believers, here is the circuit in action:

Here is the Arduino sketch for the demonstration above (download).

Now for the prototype of something more useful – another clock. :) Time to once again pull out my Arduino-compatible board with onboard DS1307 real-time clock. For more information on the RTC IC and getting time data with an Arduino please visit chapter twenty of my tutorials. For this example we will use the first two digits for the hours, and the last two digits for minutes. The display will then rotate to showing the numerical day and month of the year – then repeat.

Operation is simple – just get the time from the DS1307, then place the four digits in an array. The elements of the array are then sent in reverse order to the shift registers. The procedure is repeated for the date. Anyhow, here is the sketch (download). And the clock in action:

So there you have it – another older style of technology dragged into the 21st century. If you enjoyed this article you may also like to read about vintage HP LED displays. Once again, I hope you found this article of interest. Thanks to the Vintage Technology Association website for background information.

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Sunday, April 22, 2012

Tektronix CFC250 Teardown

ntroduction

Time for something different – and perhaps the start of several new articles containing teardowns. In our first instalment we examine the Tektronix CFC250 100 MHz frequency counter circa 1994: Not the most spectacular of designs, but it has worked well right until the present day. The update speed of the display wasn’t lightning fast, however for the time it would have been quite reasonable. Here is a short video I shot last year comparing it against a small frequency counter kit:

However after staring at this thing every day on my desk for a couple of years it has now become impossible to overcome the temptation to have a look inside. Therefore the reason for this article. You can click on the images to see the full-size version. So let’s go back to 1988 and check out the CFC250…

External tour

A quick look around the outside. The casing is reminiscent of the Escort brand of test equipment from the era, and (I suspect that) they OEM’d the CFC250 for Tektronix. (Interestingly enough Agilent bought the assets of Escort in 2008). Moving forward, the external images of the CFC250 starting with the front:

… and the rear. The AC transformer is tapped out to accept four different mains voltages, which you can select with the slide switches:

Opening up the unit involves removing screws from the base. The first ones were only for the feet, so they could stay put:

It was the screw on the right of the foot that was the key to entry. After removing them from each side and the other pair on the rear-bottom, the top casing pulls off easily…

Internal tour

… leaving us with the internals for all to see:

Although the LED display is a fair giveaway to the age of the CFC250,  a quick look around the PCB confirms it… and the display is ultimately controlled by an LSI Systems LS7031 “Six decade MOS up counter” (data sheet.pdf). It is matched to some DS75492N MOS-to-LED hex digit driver ICs (data sheet.pdf) and some other logic ICs. It is interesting to compare the number of parts required to drive the LEDs compared to a contemporary microcontroller and something like the TM1640 used in this module.

Now for the LED display board:

Nothing too out of the ordinary. A closer look at the rear panel shows some very neat AC mains wiring:

Now for some more close-ups. Here we can see the use of the MM5369 17-stage oscillator/divider (data sheet.pdf). I haven’t seen one of these for a while, the last time we used them was for a 60Hz timebase. However in this case it would be used to create an accurate timebase within which the CFC250 would count the number of incoming pulses:

 The removal of two more screws allows removal of the main PCB from the base of the cabinet, which reveals as such:

There is also an opaque plastic sheet cut to fit, helping insulate the PCB from the rest of the world:

Question – In which year was Tektronix founded?

 The PCB is single-sided and very easy to follow. I wonder if it was laid out by hand?

It reminds me of some old kits from the past decade.  Moving forward, there is a metal shield around the PCB area of signal input and low-pass filter:

A quick desolder of three points allows removal of the shield, and reveals the following:

At the top-left of the above image reveals a resistor in a somewhat elevated position, as shown below:

If anyone can explain this one, please leave a comment below.

 Conclusion

What impressed me the most during this teardown was the simple way in that the unit was designed – all through-hole parts, mechanical connections either soldered or nuts and bolts, and all components labelled. I can imagine that during the lifespan of the CFC250 it would have been relatively simple to repair. Such is the price of progress. And yes, it worked after putting it all back together again.

In the meanwhile, full-sized original images are available on flickr. I hope you found this article of interest. Coming soon we will have some more older-technology items to examine and some new tutorials as well.

In the meanwhile, have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Sunday, April 8, 2012

Arduino and TM1640 LED Display Modules

Introduction

The purpose of this article is to demonstrate the use of the second (here’s the first) interesting LED display module I discovered on the dealextreme website, for example:

As you can see the display unit holds a total of sixteen seven-segment LED digits using four modules. However thanks to the use of the TM1640 controller IC

… the entire display is controlled with only four wires – 5V, GND, data in and clock:

The board also ships with the 30cm long four-wire lead and fitted plug. Finally, there is a ‘power on’ LED on the right-hand end of the board:

Getting Started

Now to make things happen. From a hardware perspective – it couldn’t be easier. Connect the 5V and GND leads to … 5V and GND. The data and clock leads will connect to two Arduino digital pins. That’s it. The maximum current drawn by the display with all segments on is ~213mA:

So you should be able to drive this from a normal Arduino-compatible board without any hassle. Please note that the TM1640 IC does heat up somewhat, so you may want to consider some sort of heatsink if intending to max out the display in this manner.

From the software side of things you will need to download and install the TM1638 library (yes) which also handles the TM1640 chip. To simply display text from a string on the display, examine the following sketch:

#include  // yes you need both #include <TM1640.h>
// define a module on data pin 7, clock pin 8 TM1640 module(7, 8);
void setup() { // nothing to do here }
void loop() { String name = "0123456789012345"; module.setDisplayToString(name, 0b0000000000000000); delay(32766); }

Which will display:

The sixteen digit binary number in the module.setDisplayToString() line controls the decimal points – 0 for off and 1 for on. For example, changing it to

0b1010101010101010

will display:

You can also display text in a somewhat readable form – using the characters available in this list.

Displaying numbers is very easy, you can address each digit individually using:

module.setDisplayDigit(x, y, true/false);

where x is the digit, y is the position (0~15), and true/false is the decimal point. At this time you can’t just send a long integer down to the display, so you will need to either convert your numbers to a string or failing that, split it up into digits and display them one at a time.

In the following example sketch we display integers and unsigned integers by using the C command sprintf(). Note the use of %i to include an integer, and %u for unsigned integer:

#include  // required because the way arduino deals with libraries #include
// define a module on data pin 7, clock pin 8 TM1640 module(7, 8);
void setup() { // nothing to do here }
void loop() { char text[17]; int z;
for (z=0; z<5; z++) { int a=32767; sprintf(text, "INTEGER %i",a); module.setDisplayToString(text);  delay(1000); module.clearDisplay();
unsigned int ui=65535; sprintf(text, "UNSIGNED %u",ui); module.setDisplayToString(text); delay(1000); module.clearDisplay(); }  for (z=0; z<32767; z++) { sprintf(text, "COUNTING %i",z); module.setDisplayToString(text);  delay(10); } }

And the resulting output:

Now you have an idea of what is possible, a variety of display options should spring to mind. For example:

Again, this display board was a random, successful find. When ordering from dealextreme, do so knowing that your order may take several weeks to arrive as they are not the fastest of online retailers; and your order may be coming from mainland China which can slow things down somewhat. Otherwise the module worked well and considering the minimal I/O and code requirements, is a very good deal.

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Saturday, April 7, 2012

Hewlett-Packard 5082-7415 LED Display from 1976

In this article we examine a five digit, seven-segment LED display from Hewlett-Packard, the 5082-7415:

According to the data sheet (HP 5082-series.pdf) and other research this was available for a period of time around 1976 and used with other 5082-series modules in other HP products. Such as the Hewlett-Packard 3x series of calculators, for example:

http://www.hpmuseum.org/" src="http://www.hpmuseum.org/31.jpg" height="379" alt="" style="display: block; margin-left: auto; margin-right: auto; border: 1px solid #333333;" width="199" />

Using the display is very easy – kudos to the engineers at HP for making a simple design that could be reusable in many applications. The 5082-7415 is a common-cathode unit and wiring is very simple – there are the usual eight anodes for segments a~f and the decimal point, and the five cathodes.

Question – Name three HP calculators that use LED displays

As this module isn’t too easily replaceable, I was very conservative with the power supply – feeding just under 1.6V at 10mA to each of the anode pins. A quick test proved very promising:

Excellent – it worked! But now to get it displaying some sort of interesting way. Using the following hardware…

  • Freetronics Eleven Arduino-compatible board
  • Two 74HC595 shift registers
  • Eight 560 ohm resistors
  • Five 1k ohm resistors
  • Five BC548 transistors
  • A large solderless breadboard and plenty of wires

… it was connected in the same method as a four-digit display (except for the extra digit) as described in mytutorial. Don’t forget to use the data sheet (HP 5082-series.pdf). You don’t have to use Arduino – any microcontroller with the appropriate I/O can take care of this.

Here is a simple Arduino sketch that scrolls through the digits with and then without the decimal point (download):

// Arduino sketch to demonstrate HP 5082-7415 LED Display unit // John Boxall, April 2012
int clockPin=6; int latchPin=7; int dataPin=8;
// array for cathodes - sent to second shift register byte digits[]={
B10000000, B01000000, B00100000, B00010000, B00001000, B11111000}; // use digits[6] to turn all on
// array for anodes (to display 0~0) - sent to first shift register byte numbers[]={
B11111100, B01100000, B11011010, B11110010, B01100110, B10110110, B10111110, B11100000, B11111110, B11110110};
void setup() { pinMode(clockPin, OUTPUT); pinMode(latchPin, OUTPUT); pinMode(dataPin, OUTPUT); }
void loop() { int i; for ( i=0 ; i<10; i++ ) { digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, digits[6]); shiftOut(dataPin, clockPin, LSBFIRST, numbers[i]); digitalWrite(latchPin, HIGH); delay(250); } // now repeat with decimal point for ( i=0 ; i<10; i++ ) { digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, digits[6]); shiftOut(dataPin, clockPin, LSBFIRST, numbers[i]+1); digitalWrite(latchPin, HIGH); delay(250); } }

And the results:

Now for something more useful. Here is a function that sends a single digit to a position on the display with the option of turning the decimal point on or off:

void displayDigit(int value, int posit, boolean decPoint) // displays integer value at digit position posit with decimal point on/off { digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, digits[posit]); if (decPoint==true) { shiftOut(dataPin, clockPin, LSBFIRST, numbers[value]+1);  }  else  { shiftOut(dataPin, clockPin, LSBFIRST, numbers[value]);  } digitalWrite(latchPin, HIGH); }

So if you wanted to display the number three in the fourth digit, with the decimal point – use

  displayDigit(3,3,true);

with the following result:

We make use of the displayDigit() function in our next sketch. We introduce a new function

displayInteger(number,cycles);

It accepts a long integer between zero and 99999 (number) and displays it on the module for cycles times. You can download the sketch from here.

// Arduino sketch to demonstrate HP 5082-7415 LED Display unit // Displays numbers on request // John Boxall, April 2012
int clockPin=6; int latchPin=7; int dataPin=8;
// array for cathodes - sent to second shift register byte digits[]={ B10000000, B01000000, B00100000, B00010000, B00001000, B11111000}; // use digits[6] to turn all on
// array for anodes (to display 0~0) - sent to first shift register byte numbers[]={ B11111100, B01100000, B11011010, B11110010, B01100110, B10110110, B10111110, B11100000, B11111110, B11110110};
void setup() { pinMode(clockPin, OUTPUT); pinMode(latchPin, OUTPUT); pinMode(dataPin, OUTPUT); randomSeed(analogRead(0)); }
void clearDisplay() // turns off all digits { digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, 0); shiftOut(dataPin, clockPin, LSBFIRST, 0);  digitalWrite(latchPin, HIGH); }
void displayDigit(int value, int posit, boolean decPoint) // displays integer value at digit position posit with decimal point on/off { digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, digits[posit]); if (decPoint==true) { shiftOut(dataPin, clockPin, LSBFIRST, numbers[value]+1);  }  else  { shiftOut(dataPin, clockPin, LSBFIRST, numbers[value]);  } digitalWrite(latchPin, HIGH); }
void displayInteger(long number,int cycles) // displays a number 'number' on the HP display.  { long i,j,k,l,z; float f; clearDisplay(); for (z=0; z
void loop() { long l2; l2=random(0,100001); displayInteger(l2,400); }

For demonstration purposes the sketch displays random numbers, as shown in the video below:

Finally after some more hunting around I found some four-digit knock-off versions on eBay (item #120876219746) , so have ordered them and will report back once they arrive. In the meanwhile, I hope you found this article of interest. Thanks to the Vintage Technology Association website and the Museum of HP Calculators for background information and Freetronics for the use of the Eleven.

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Tuesday, April 3, 2012

April 2012 Competition

Welcome back!

Another month and time for another competition! First we’ll look at the prizes, and then examine the rules of entry.

First Prize is a new Freetronics DMD – Dot Matrix Display as reviewed recently and used in Clock One:

The DMD consists of 16 rows of 32 LEDs that can run directly from an Arduino-compatible board, or at a much higher brightness using an external power supply. It is simple to program for yet a load of fun to use. Specifications include:

  • 32 x 16 high brightness Red LEDs (512 LEDs total) on a 10mm pitch
  • 5V operation
  • Viewable over 12 metres away
  • Tough plastic frame
  • Controller ICs on board, simple clocked data interface
  • Arduino compatible library, graphics functions and example support
  • Dimensions: 320(W) x 160(H) x 14(D)mm (30mm(D) including rear connectors)

The winner can select either a red DMD as shown in the video above or a blue one as such:

Second Prize consists of one each of the eleven modules from the Freetronics Module/Sensor range, as reviewed recently:

With this range of modules you will be able to sense temperature, humidity, magnetic fields, light and sound pressure levels, sound and shock. Plus light up with the RGB LED, get more I/O with the expansion module, interface with the level shifter board, control high currents with the N-MOSFET, and power the lot with the tiny switch mode power supply. Available from Freetronics or a reseller near you.

How to enter!

There will be five questions for you to answer spread across articles published between the 1st and 30th of April.  At the end of April and once you have answers to all five questions, email the answers along with yourfull name, email address and postal address to competition at tronixstuff dot com with the subject heading April.

During the second week of May, all the correct entries will be collated and two randomly chosen. The first correct entry drawn will win first prize, and the second entry the second prize. Entries will be accepted until 02/05/2012 0005h GMT.

As with any other competition, there needs to be some rules:

  • Incomplete entries will be rejected, so follow the instructions!
  • The winners’ first name and country will be announced publicly;
  • The winners’ name and mailing address will be passed to the prize supplier only for the purpose of prize delivery and not for any form of marketing.
  • Entries that contain text not suitable for minors or insulting to the competition will be rejected (seriously – it happens);
  • Prizes will be delivered via Australia Post domestic or regular international air mail. We take absolutely no responsibility for packages that go missing or do not arrive. If you live in an area with a “less than reliable” domestic postage system, you can pay for registered mail or other delivery service at your expense.
  • Winners outside of Australia will be responsible for any taxes, fees or levies imposed by your local Governments (such as import levies, excise, VAT, etc.) upon importation of purchased goods;
  • Prizes may take up to 45 days to be received;
  • No disputes will be entered in to;
  • Prizes carry no warranty nor guarantee – and are to be used or abused at entirely your own risk;
  • Entries will be accepted until 02/05/2012 0005h GMT.

Thanks to Freetronics for the prizes!

 In the meanwhile, have fun and keep an eye out for the four competition questions spread through the February posts… In the meanwhile, follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.