Archive | product review

Review – Freetronics 128×128 Pixel Colour OLED Module


Time for another review, and in this instalment we have the new 128×128 Pixel OLED Module from Freetronics. It’s been a while since we’ve had a full-colour graphic display to experiment with, and this one doesn’t disappoint. Unlike other displays such as LCD, this one uses OLED – “Organic Light-Emitting Diode” technology.

OLEDs allow for a faster refresh rate, and to the naked eye has a great amount of colour contrast. Furthermore the viewing angles are excellent, you can clearly read the display from almost any angle, for example:

freetronics OLED display bottom view

freetronics OLED display side

However they can suffer from burn-in from extended display of the same thing so that does need to be taken into account. Nevertheless they provide an inexpensive and easy-to-use method of displaying colour text, graphics and even video from a variety of development boards. Finally – there is also a microSD socket for data logging, image storage or other uses. However back to the review unit. It arrives in typical retail packaging:

freetronics OLED display

and includes the OLED display itself, a nifty reusable parts tray/storage box, and two buttons. The display has a resolution of 128 x 128 pixels and has a square display area with a diagonal size of 38.1 mm. The unit itself is quite compact:

freetronics OLED display front


The display is easily mounted using the holes on the left and right-hand side of the display. The designers have also allowed space for an LED, current-limiting resistor and button on each side, for user input or gaming – perfect for the  included buttons. However this section of the PCB is also scored-off so you can remove them if required. Using the OLED isn’t difficult, and tutorials have been provided for both Arduino and Raspberry Pi users.

Using with Arduino

After installing the Arduino library, it’s a simple matter of running some jumper wires from the Arduino or compatible board to the display – explained in detail with the “Quickstart” guide. Normally I would would explain how to use the display myself, however in this instance a full guide has been published which explains how to display text of various colours, graphics, displaying images stored on a microSD card and more. Finally there’s some interesting demonstration sketches included with the library. For example, displaying large amounts of text:

… the variety of fonts available:

freetronics OLED font demonstration

… and for those interested in monitoring changing data types, a very neat ECG-style of sketch:

… and the mandatory rotating cube from a Freetronics forum member:

Using with Raspberry Pi

For users of this popular single-board computer, there’s a great tutorial and some example videos available on the Freetronics website for your consideration, such as the following video clip playback:


Along with the Arduino and Raspberry Pi tutorials, there’s also the Freetronics support forum where members have been experimenting with accelerated drivers, demonstrations and more.


For a chance to win your own OLED display, send a postcard with your email address clearly printed on the back to:

OLED Competition, PO Box 5435 Clayton 3168 Australia. 

Cards must be received by 24/10/2013. One card will then be selected at random and the winner will be sent one Freetronics OLED Display. Prize will be delivered by Australia Post standard air mail. We’re not responsible for customs or import duties, VAT, GST, import duty, postage delays, non-delivery or whatever walls your country puts up against receiving inbound mail.


Compared to previous colour LCD units used in the past, OLED technology is a great improvement – and demonstrated very well with this unit. Furthermore you get the whole package – anyone call sell you a display, however Freetronics also have the support, tutorials, drivers and backup missing from other retailers. So if you need a colour display, check it out.

And for more detail, full-sized images from this article can be found on flickr. And if you’re interested in learning more about Arduino, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop” from No Starch Press.

In the meanwhile have fun and keep checking into 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.

[Note – OLED display was a promotional consideration from Freetronics]

Posted in arduino, freetronics, LCD, OLED, product review, raspberry pi, review, tutorial0 Comments

Book – “Arduino Workshop – A Hands-On Introduction with 65 Projects”

Over the last few years I’ve been writing a few Arduino tutorials, and during this time many people have mentioned that I should write a book. And now thanks to the team from No Starch Press this recommendation has morphed into my new book – “Arduino Workshop“:


Although there are seemingly endless Arduino tutorials and articles on the Internet, Arduino Workshop offers a nicely edited and curated path for the beginner to learn from and have fun. It’s a hands-on introduction to Arduino with 65 projects – from simple LED use right through to RFID, Internet connection, working with cellular communications, and much more.

Each project is explained in detail, explaining how the hardware an Arduino code works together. The reader doesn’t need any expensive tools or workspaces, and all the parts used are available from almost any electronics retailer. Furthermore all of the projects can be finished without soldering, so it’s safe for readers of all ages.

The editing team and myself have worked hard to make the book perfect for those without any electronics or Arduino experience at all, and it makes a great gift for someone to get them started. After working through the 65 projects the reader will have gained enough knowledge and confidence to create many things – and to continue researching on their own. Or if you’ve been enjoying the results of my thousands of hours of work here at tronixstuff, you can show your appreciation by ordering a copy for yourself or as a gift 🙂

You can review the table of contents, index and download a sample chapter from the Arduino Workshop website.

Arduino Workshop is available from No Starch Press in printed or ebook (PDF, Mobi, and ePub) formats. Ebooks are also included with the printed orders so you can get started immediately.


In the meanwhile have fun and keep checking into 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.

Posted in arduino, Arduino Workshop, book, books, cellular, clocks, display, distance, ds1307, DS3232, education, EEPROM, freetronics, GPS, graphic, GSM, hardware hacking, I2C, internet, LCD, learning electronics, lesson, no starch press, numeric keypad, part review, product review, projects, RDM630, RDM6300, relay, review, sensor, servo, SMS, time clock, timing, tronixstuff, tutorial, twitter, wireless, xbee13 Comments

Review – Schmartboard SMT Boards

In this article we review a couple of SMT prototyping boards from Schmartboard.


Sooner or later you’ll need to use a surface-mount technology component. Just like taxes and myki* not working, it’s inevitable. When the time comes you usually have a few options – make your own PCB, then bake it in an oven or skillet pan; get the part on a demo board from the manufacturer (expensive); try and hand-solder it yourself using dead-bug wiring or try to mash it into a piece of strip board; or find someone else to do it. Thanks to the people at Schmartboard you now have another option which might cost a few dollars more but guarantees a result. Although they have boards for almost everything imaginable, we’ll look at two of them – one for QFP packages and their Arduino shield that has SOIC and SOP23-6 areas.


QFP 32-80 pin board

In our first example we’ll see how easy it is to prototype with QFP package ICs. An example of this is the Atmel ATmega328 microcontroller found on various Arduino-compatible products, for example:


Although our example has 32 pins, the board can handle up to 80-pin devices. You simply place the IC on the Schmartboard, which holds the IC in nicely due to the grooved tracks for the pins:


The tracks are what makes the Schmartboard EZ series so great – they help hold the part in, and contain the required amount of solder. I believe this design is unique to Schmartboard and when you look in their catalogue, select the “EZ” series for this technology. Moving forward, you just need some water-soluble flux:


then tack down the part, apply flux to the side you’re going to solder – then slowly push the tip of your soldering iron (set to around 750 degrees F) down the groove to the pin. For example:

Then repeat for the three other sides. That’s it. If your part has an exposed pad on the bottom, there’s a hole in the centre of the Schmartboad that you can solder into as well:


After soldering I really couldn’t believe it worked, so probed out the pins to the breakout pads on the Schmartboard to test for shorts or breaks – however it tested perfectly. The only caveat is that your soldering iron tip needs to be the same or smaller pitch than the the part you’re using, otherwise you could cause a solder bridge. And use flux!  You need the flux. After soldering you can easily connect the board to the rest of your project or build around it.

Schmartboard Arduino shield

There’s also a range of Arduino shields with various SMT breakout areas, and we have the version with 1.27mm pitch SOIC and a SOT23-6 footprint. SOIC? For example:


This is the AD5204 four-channel digital potentiometer we used in the SPI tutorial. It sits nicely in the shield and can be easily soldered onto the board. Don’t forget the flux! Although the SMT areas have the EZ-technology, I still added a little solder of my own – with satisfactory results:

The SOT23-6 also fits well, with plenty of space for soldering it in. SOT23? Example – the ADS1110 16-bit ADC which will be the subject of a future tutorial:


Working with these tiny components is also feasible but requires a finer iron tip and a steady hand.


Once the SMT component(s) have been fitted, you can easily trace out the matching through-hole pads for further connections. The shield matches the Arduino R3 standards and includes stacking header sockets, two LEDs for general use, space and parts for an RC reset circuit, and pads to add pull-up resistors for the I2C bus:


Finally there’s also three 0805-sized parts and footprints for some practice or use. It’s a very well though-out shield and should prove useful. You can also order a bare PCB if you already have stacking headers to save money.


If you’re in a hurry to prototype with SMT parts, instead of mucking about – get a Schmartboard. They’re easy to use and work well.  Full-sized images available on flickr.

In the meanwhile have fun and keep checking into 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.

The boards used in this article were a promotional consideration supplied by Schmartboard.


Posted in arduino, product review, review, safety, schmartboard, SMD, SMT, soic, soldering, sot-23, tqfp, tronixstuff, tutorial2 Comments

Exploring the TI Stellaris platform with Energia Arduino-compatible IDE


In the same manner as their MSP430 development board, Texas Instruments also have another LaunchPad board with their powerful Stellaris LM4F120H5QR microcontroller. It’s an incredibly powerful and well-featured MCU – which offers an 80 MHz, 32-bit ARM Cortex-M4 CPU with floating point, 256 Kbytes of 100,000 write-erase cycle FLASH and many peripherals such as 1MSPS ADCs, eight UARTs, four SPIs, four I2Cs, USB & up to 27 timers, some configurable up to 64-bits.

That’s a bucket of power, memory and I/O for not much money – you can get the LaunchPad board for around $15. This LaunchPad has the in-circuit debugger, two user buttons, an RGB LED and connectors for I/O and shield-like booster packs:

and the other side:

However the good news as far as we’re concerned is that you can now use it with the Energia Arduino-compatible IDE that we examined previously. Before rushing out to order your own Stellaris board, install Energia and examine the available functions and libraries to make sure you can run what you need. And if so, you’re set for some cheap Arduino power.


Installation is simple, just get your download from here. If you’re running Windows 7 – get the USB drivers from here. When you plug your LaunchPad into the USB for the first time, wait until after Windows attempts to install the drivers, then install drivers manually after download via Device manager … three times (JTAG, virtual serial port and DFU device). Use the debug USB socket (and set the switch to debug) when installing and uploading code. If you get the following warning from Windows, just click “Install this driver software anyway”:

Once the drivers are installed, plug in your LaunchPad, wait a moment – then run Energia. You can then select your board type and serial port just like the Arduino IDE. Then go ahead and upload the “blink” example…


Awesome – check out all that free memory space. In the same manner as the MSP430, there are some hardware<>sketch differences you need to be aware of. For example, how to refer to the I/O pins in Energia? A map has been provided for front:


… and back:


As you can imagine, the Stellaris MCUs are different to an AVR, so a lot of hardware-specific code doesn’t port over from the world of Arduino. One of the first things to remember is that the Stellaris is a 3.3V device. Code may or may not be interchangeable, so a little research will be needed to match up the I/O pins and rewrite the sketch accordingly. For example, instead of digital pins numbers, you use PX_Y – see the map above. So let’s say you want to run through the RGB LED… consider the following sketch:

Which simply blinks the red, green and blue LED elements in series. Using digital inputs is in the same vein, and again the buttons are wired so when pressed they go LOW. An example of this in the following sketch:

And for the non-believers:

Where to from here? 

Sometimes you can be platform agnostic, and just pick something that does what you want with the minimum of time and budget. Or to put it another way, if you need a fast CPU and plenty of space but couldn’t be bothered don’t have time to work with Keil, Code Composer Studio, IAR etc – the Energia/Stellaris combination could solve your problem. There’s a growing Energia/Stellaris forum, and libraries can be found here. At the time of writing we found an I2C library as well.

However to take full advantage of the board, consider going back to the TI tools and move forward with them. You can go further with the tutorials and CCS etc from Texas Instruments own pages.

In the meanwhile have fun and keep checking into 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.

Posted in arduino, arm cortex, energia, launchpad, lesson, LM4F120H5QR, MSP430, product review, software review, stellaris, TI, tiva-c, tutorial2 Comments

Review: Agilent U1177A IR to Bluetooth Adaptor

In this review we examine the new Agilent U1177A infra-red to Bluetooth adaptor for the Agilent  U1272A DMM. You can also use the adaptor with the U1240-series DMMs with the optional adaptor. With some PC or Android device software you can monitor or log data from up to three DMMs. So let’s have a look and see what it’s all about.


The adaptor arrives in a small box:

… with the following contents:

It was a relief to see the AAA cells included as we didn’t have any in stock. The yellow document is the China RoHS sheet, and the instructions are short but well detailed. The unit itself is quite small:

To fit the battery or reset the device, the front cover slides open revealing the innards to some degree:

and the rear:

The unit clips soundly to the rear of the DMM, however it does stick out quite a lot:

If you need to leave the meter unattended, you’ll need a level and vibration free surface, as the adaptor can be knocked out relatively easily from the top. The adaptor also blocks the hole at the back which some users may use with a hook or loop for positioning the DMM.

Software and Operation

You can use the U1177 with two platforms – Android and Windows, and we tested both. I’m sure if you have Mac Parallels, etc., that there may be some success there but I haven’t tested them. There are two applications available for Android devices – the mobile logger and mobile meter. You can download them both from the Google Play app – just search for ‘agilent‘, and the results should be

The third app is a game that is somewhat entertaining. We tried the applications on two Android devices – a HTC Velocity running Android 4.0.3 (which failed miserably, the software kept freezing) and a Motorola Xoom MZ601 with Android 3.2. I would say now that the software is marked “Beta” so caveat emptor. The data logging software worked on the Xoom but not the “Agilent Mobile Meter”. Moving forward, the logging software is quite good – you can display a graph, table or statistical value of the incoming data from up to three separate DMMs.

Below is a rough video of using the Xoom with data logging. We first make the Bluetooth connection, then measure resistance of a 1k ohm logarithmic pot, change the view to data table, then stop the logging and email the data. The app can email a .csv file which can be opened with any spreadsheet, etc. Using the app you can label each DMM feed to avoid confusion with the data files in the future.

Using the U1177A with a Windows 7 x64 machine was a lot more successful. You can download the Windows-based software from here (97 MB). After pairing the adaptor with the bluetooth connection software, the Agilent software loads but does not connect. You need to alter the data speed to 19200bps and select the COM port from the drop-down list in the “communication settings” on the left-hand side of the window, as shown below:

You can also use terminal software and AT commands to change the parameters of the U1177A, which is described in the user manual. Moving forward, once connected you can measure and log to your heart’s content. You can display a virtual meter:


Or choose a graphing display mode:


Note the short drop in value to zero as the graph increased on the far-right of the measurement in the image above. This occurs when the meter is changing range, just as the LCD will blink off then on due to the same phenomenon. Finally, you can also display the data as a table, for example:


Finally, you can export the data to a .csv file which can be opened with the usual spreadsheet or text editing software:


Using Windows OS Remote Multimeter Use Data Logging Other connection – hyperterminal etc. 


For data logging to a PC that is in Bluetooth range, the U1177A fits the bill. Although you can get a serial to IR cable (and early U1272A owners should have received one when the firmware update was released), the Bluetooth module will certainly be useful when moving around a worksite, or taking remote measurements from extreme temperature or NVH environments. The Android apps need to move out of beta stage – however due to the variety of devices and OS versions in the market this may be a long journey. However considering the price (~Au$52) it is inexpensive enough to keep around just-in-case.

Note – the U1177A was purchased by myself and reviewed without notice. Residing in Australia, ours was purchased from

In the meanwhile have fun and keep checking into 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.

Posted in agilent, android, bluetooth, multimeter, product review, review, test equipment, U1177A, U1272A2 Comments

Arduino meets Las Vegas with the Freetronics DMD

Updated 05/11/2014

Time once more to have some fun, and this time by examining the Freetronics DMD “Dot Matrix Display” available from Tronixlabs. We will look at the setup and operation of the display. In a nutshell the DMD comprises of a board measuring approximately 320mm across by 160mm which contains 16 rows of 32 high-intensity red LEDs. For example, in the off state:

Connection of the DMD to your Arduino-compatible board is quite simple. Included with each DMD is a 2×8 IDC cable of around 220mm in length, and a PCB to allow direct connection to the Arduino digital pins D6~13:

Finally the cable connects to the left-hand socket on the rear of the DMD:

You can also daisy-chain more than one display, so a matching output socket is also provided. Finally, an external power supply is recommended in order to drive the LEDs as maximum brightness – 5V at ~4 A per DMD. This is connected to a separate terminal on the rear of the board:

Do not connect these terminals to the 5V/GND of your Arduino board!

A power cable with lugs is also included so you can daisy chain the high-intensity power feeds as well. When using this method, ensure your power supply can deliver 5V at 4A  for each DMD used – so for two DMDs, you will need 8A, etc. For testing (and our demonstration) purposes you can simply connect the DMD to your Arduino via the IDC cable, however the LEDs will not light at their full potential.

Using the display with your Arduino sketches is quite simple. There is an enthusiastic group of people working on the library which you will need, and you can download it from and follow the progress at the DMD Github page and forks. Furthermore, there is always the Freetronics forum for help, advice and conversation. Finally you will also need the TimerOne library – available from here.

However for now let’s run through the use of the DMD and get things moving. Starting with scrolling text – download the demonstration sketch from here. All the code in the sketch outside of void loop() is necessary. Replace the text within the quotes with what you would like to scroll across the display, and enter the number of characters (including spaces) in the next parameter. Finally, if you have more than one display change the 1 to your number of displays in #define DISPLAYS_ACROSS 1.

Here is a quick video of our example sketch:

Now for some more static display functions – starting with clearing the display. You can use

to turn off all the pixels, or

to turn on all the pixels.

Note: turning on more pixels at once increases the current draw. Always keep this in mind and measure with an ammeter if unsure. 

Next some text. First you need to choose the font, at the time of writing there were two to choose from. Use

for a smaller font or

for a larger font. To position a single character on the DMD, use:

which will display the character ‘x’ at location x,y (in pixels – starting from zero). For example, using

results with:

Note if you have the pixels on ‘behind’ the character, the unused pixels in the character are not ‘transparent’. For example:

However if you change the last parameter to GRAPHICS_NOR, the unused pixels will become ‘transparent’. For example:

You can also use the parameter GRAPHICS_OR to overlay a character on the display. This is done with the blinking colon in the example sketch provided with the library.

Next, to draw a string (group of characters). This is simple, just select your font type and then use (for example):

Again, the 5 is a parameter for the length of the string to display. This results in the following:

Next up we look at the graphic commands. To control an individual pixel, use

And changing the 1 to a 0 turns off the pixel. To draw a circle with the centre at x,y and a radius r, use

To draw a line from x1, y2 to x2, y2, use:

To draw a rectangle from x1, y2 to x2, y, use:

And to draw a filled rectangle use:

Now let’s put those functions to work. You can download the demonstration sketch from here, and watch the following results:

Update – the DMD is also available in other colours, such as white:

So there you have it, an inexpensive and easy to use display board with all sorts of applications. Although the demonstrations contained within this article were rather simple, you now have the knowledge to apply your imagination to the DMD and display what you like. For more information, check out the entire DMD range at Tronixlabs. And if you enjoyed this article, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a fourth printing!) “Arduino Workshop”.


Have fun and keep checking into Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our forum – dedicated to the projects and related items on this website.

Posted in arduino, dmd, freetronics, LED matrix, lesson, microcontrollers, product review, review, tronixlabs, tutorial0 Comments

Review: Mayhew Labs “Go Between” Arduino Shield

Hello readers

In this article we examine one of those products that are really simple yet can solve some really annoying problems. It is the “Go Between” Arduino shield from Mayhew Labs. What does the GBS do? You use it to solve a common problem that some prolific Arduino users can often face – how do I use two shields that require the same pins?

Using a clever matrix of solder pads, you can change the wiring between the analogue and digital pins. For example, here is the bare shield:


Now for an example problem. You have two shields that need access to digital pins 3, 4 and 5 as also analogue pins 4 and 5. We call one shield the “top shield” which will sit above the GBS, and the second shield the “bottom” shield which will sit between the Arduino and the GBS. To solve the problem we will redirect the top shield’s D3~5 to D6~8, and A4~5 to A0~1.

To redirect a pin (for example D3 to D6), we first locate the number along the “top digital pins” horizontal of the matrix (3). Then find the destination “bottom” pin row (6). Finally, bridge that pad on the matrix with solder. Our D3 to D6 conversion is shown with the green dot in the following:


Now for the rest, diverting D4 and D5 to D7 and D8 respectively, as well as analogue pins 4 and 5 to 0 and 1:


The next task is to connect the rest of the non-redirected pins. For example, D13 to D13. We do this by again bridging the matching pads:


Finally the sketch needs to be rewritten to understand that the top shield now uses D6~8 and A0~1. And we’re done!

Try not to use too much solder, as you could accidentally bridge more pads than necessary. And you can always use some solder wick to remove the solder and reuse the shield again (and again…). Now the genius of the shield becomes more apparent.

The only downside to this shield is the PCB design – the days of square corners should be over now:

It is a small problem, but one nonetheless. Hopefully this is rectified in the next build run. Otherwise the “Go Between” Shield is a solution to a problem you may have one day, so perhaps keep one tucked away for “just in case”.

While we’re on the subject of Arduino shield pinouts, don’t forget to check out Jon Oxer’s when researching your next Arduino shield – it is the largest and most comprehensive catalogue of submitted Arduino shields in existence.

[Note – the “Go Between” Shield was purchased by myself personally and reviewed without notifying the manufacturer or retailer]

Have fun and keep checking into 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.

Posted in arduino, go between, hardware hacking, mayhew labs, product review, review0 Comments

Initial Review: Akafugu Akafuino-X Microcontroller Board

Hello Readers

Time to get back to work for 2012 and in doing so we review another interesting product from a new company based in Japan – akafugu. From their website:

Akafugu Corporation is a small electronics company that operates out of Tokyo, Japan. We specialize in fun and easy to use electronic gadgets. Our goal is to provide products that not only make prototyping faster and easier, but are also perfect for incorporation in finalized products.

And with this in mind we examine the Akafuino-X microcontroller board:


The observant among you will notice the similarity to our usual Arduino Uno and compatible boards. However there are some differences which bring changes and improvements over the original Arduino design. The biggest point of difference is the microcontroller, the Akafuino uses an Atmel XMega32A4. The benefit of this over the normal ATmega328 is:

  • Speed! 32 MHz – twice as fast as the ATmega328;
  • Two-channel DAC (digital to analogue) converter – output analogue signals between 0V and Vcc straight from the board. A library is included with the new IDE to control them. The DAC uses digital pins seven and eight;
  • Not one, two or even four, but five UARTs;
  • Two I2C buses;
  • Sixteen PWM pins – great for LED effects…

Thankfully the designers have detailed the extra I/O pins and other useful information on the rear of the board:


Other changes include:

  • It’s a 3.3V board – so no 5V supply for you. However the inputs are tolerant to 5V;
  • On-board real time clock. You can also add an optional 32.768 kHz crystal to increase accuracy – see the space on the board near the reset pin;
  • A very refreshing red colour (note that ‘aka(i)’ ** is red in Japanese) and a happy puffer fish (‘fugu’) on the silk-screening 🙂
  • And libraries for other Akafugu products such as the TWI Display module are available.

Getting started is easy, however due to the difference in hardware the Arduino IDE needs modification. But don’t panic – instead of modifying your existing v1.0 Arduino IDE – download and install the Akafuino-X version from here and run your usual and the Akauino-X IDE on the same machine (it’s ok to do this). You should also review the usage instructions here and note that this is a derivative of the v1.0 IDE. Furthermore at the time of writing the software side of things is still in beta, and can be monitored via Github – however don’t let this put you off, as the Akafuino-X has a lot of potential.

If you find any bugs in use the issue tracker in Github to let the team know.

In the meanwhile we’ve conducted a quick speed test – by running the same sketch on an Arduino Uno and also the Akafuino-X. The test is a whole lot of multiplication, nothing too scientific. At the end the duration of the exercise is shown in milliseconds. Here’s the code:

And here are the results of running the sketch four times on each board:


Our Akafuino-X beta only took 2704ms versus the Arduino Uno taking 4212ms. Very good so far.

Update! The team at akafugu have been experimenting with overclocking the Akafuino-X. And also check out the errata page

So there you have it, another contender in the Arduino-compatible board stakes. Considering the extra  I/O, PWM and bus connectivity the Akafuino-X is a very capable board. I look forward to the evolution of the IDE and will return with the Akafuino-X in an upcoming project. And we also have one to give away. So stay tuned! In the meanwhile the Akafuino-X and other goodies are available directly from

Disclaimer – The parts reviewed in this article are a promotional consideration made available by akafugu.

Have fun and keep checking into 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.

** Yes I know it’s an i-type adjective

Posted in akafugu, akafuino, arduino, product review, review, XMega32A46 Comments

Initial Review – Arduino v1.0 IDE

Hello Readers

Recently the Arduino team have released version 1.0 of the IDE (integrated development environment) that we all know and love. This is a significant milestone as the IDE has previously been in alpha release since 2005. For the platform to have survived and thrived this long is a credit to the community and especially to the Arduino team themselves.

Arduino? Not sure where to start? There’s a couple of tutorials right hereOr buy my book!

[Update 13/07/2013… this review is probably moot as the Arduino IDE v1 and greater has become prevalent. However if you’re still using v23 for some reason, keep reading]

Moving forward, let’s have a look and see what has changed:

Installation is quite simple. As always, download the IDE from the Arduino website. Before installing the new version, copy and backup your sketchbook folder and the entire folder system of your current IDE installation. This shouldn’t take long as … I’m sure everyone does this on a regular basis. The move to v1.0 is a major one, and you will still need to use the older IDE – so don’t delete it from your computer.

Once installed, copy over the contents of your ../arduino-002x/libraries folder to the new ../arduino-1.0/libraries folder. When your operating systems pauses and asks what to do with duplicate folders, click “skip”. That is, don’t overwrite the new libraries with old ones.

Now run the new IDE, and you will be presented with the following (note we have already loaded the “blink” example):


The cosmetic changes in the design of the tool bar are slight yet refreshing. The buttons in order are: verify (we used to call this “compile”), upload sketch, file new, file open, file save and the serial monitor button has been moved across to the far right.

At the very bottom-right of the IDE window the board type and port connection is displayed – which is great if you are working with more than one Arduino board at once – a nifty feature. Furthermore when verifying and uploading a sketch, a progress bar appears at the top right of the message window, for example:

The last cosmetic change that became apparent is the automatic creating of hyperlinks in the sketch when the IDE detects a correctly-formatted URL, for example:

Cosmetic changes are all well and good, however that is only the tip of the iceberg. For starters, the file extension for sketches compatible with v1.0 is now .ino.

The next thing is to review the update release notes, also listed below with my own notes – where a lot of surprises can be found. As listed below, several functions and libraries have changed in behaviour or existence. Therefore some work may be required to convert sketches from v23 IDE to v1.0. At the current time I can’t see any reason to do this, and if you have any projects relying on existing libraries – make a backup copy of your existing environment in case the original source of the library disappears. The Arduino team have mentioned the idea of a centralised repository for libraries, however this has not been finalised at the time of writing this article.

The new Serial.print() behaviour is interesting. Let’s compare the output of the following sketch:

Using IDE v23, the output from the serial monitor is:

However when we run the same sketch in IDE v1.0, the output is:

So if you need the actual ASCII characters represented by the BYTE variable, use Serial.write() not Serial.print().

Well this is interesting. The ability to parse incoming serial data will make using that nefarious GSM shield easier…

One less library to worry about…

This should help us use memory more efficiently…

Frankly I’m not a genius when it comes to the Internet area, however clearer naming is a plus 🙂

Looks like another mental note to make when working with I2C and v1.0

Well this is a win, now multiple forms of data can be logged into separate files. As mentioned at the start, this is an initial review and by all means not complete. Feel free to leave your comments or notes for others to review as well, and as always if you find any errors please let us know.

For now the new IDE is an interesting juncture in the Arduino evolution. For new sketches and development in general there wouldn’t be any reason not to use it, as you can happily run several versions of the IDE on a single computer. However – there is a lot of published material that will not work with the new IDE – and all this will need to be updated, or at least noted by the authors concerned telling people to use an older IDE. And for this I am not too happy – the Arduino world has had a virtual “axe” chopped through it, breaking a lot of things which will take some time to move forward from.

So in the meanwhile, backup your existing libraries, your older IDE software, and be prepared to run two IDE systems in parallel for the near future.

Have fun and keep checking into 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.

Posted in arduino, IDE, product review, review, tutorial6 Comments

Review: Gravitech 7-Segment Arduino Shield

Hello Readers

In this article we examine the “7-Segment Arduino Shield” received for review from the team at Gravitech in the United States. This is an Arduino Uno/Duemilanove-type compatible shield that contains four very useful items:

  • Four 7-segment LED numerical displays – driven by the NXP SAA1064 LED display driver IC;
  • A large 10mm RGB LED;
  • A Microchip 24LC128 EEPROM, and
  • A TI TMP75 digital temperature sensor.
Apart from the LED all the other components are controlled via the I2C bus. So as well as being generally useful for experimenting, monitoring temperature and so on, this is an ideal board for Arduino and I2C bus practice. (If you have not done so already, consider reading our I2C tutorial, part one and two). Let’s look at the hardware, then move on to using the features.
As with other Gravitech products, the shield arrives in a reusable static shielding bag:
and here we have it:
The IC at the top-left of the shield is the TMP75 temperature sensor, bottom-left is the 24LC128 EEPROM, and the whopper below the first two digits is the NXP SAA1064. The shield layout is very neat and clean, and the white finish is a pleasant change compared to the usual black or green Arduino shields out there. The PWR LED is a blue colour. The only issues I found were that you cannot use this with a Mega due to the location of the I2C pins, and the component leads were not trimmed at the factory, which caused an issue when the shield was inserted into an Ethernet shield. This is easily solved by clipping the leads yourself:
Here is the shield in operation using the supplied demonstration sketch. The temperature is displayed in Celsius, with the LED changing colour depending on the temperature:

That is all very good, but how do we use the features of the board? Let’s look at each of the aforementioned features individually. First of all, the numeric display. The four seven-segment LED displays are controlled by the NXP SAA1064 LED display driver (data sheet (.pdf)). I have written a separate tutorial on how to use this IC, and it is completely compatible with this shield. So visit the tutorial here and put the numbers to work! Please note the I2C bus address for the SAA1064  is 0x38.

Next we have the RGB LED. Red, green and blue are connected to digital pins 3, 5 and 6 respectively. These are also pulse-width modulation pins, so you can have altering the brightness. Here is a simple demonstration sketch:

And for the curious, here it is in action:

Next, the Microchip 24LC128 EEPROM. It has 128kbit storage space, which translates to 16 kilobytes. The I2C bus address is 0x50. Once again there is a complete explanation of how to use this sort of EEPROM in another tutorial – check it out. But for quick reference the following demonstration sketch writes the numbers 0~255 to memory locations 0~255:

Although there is 16 kilobytes of memory the sketch only writes and reads to the first 255 locations. Each location can store a byte of value between zero and 255. Here is a screen shot of the serial monitor results (click to enlarge):

And now time to work with the Texas Instruments TMP75 temperature sensor (data sheet.pdf). It has a reasonable operating temperature range of between -40 and 125 degrees Celsius – however this would exceed the range in which your Arduino is capable of working, so no leaving the shield on the car dashboard during a hot summer’s day. The I2C bus address for the TMP75 is 0x49. We will deconstruct the Gravitech demonstration sketch to explain how the temperature works.

The TMP75 needs to be initialised before measurement can take place, by sending the following data:

The temperature data is received in two bytes of data, as it spans 12 bits. Thankfully the demonstration sketch has done the work for us. Have a look at the Cal_temp() function, which converts the two raw bytes of data from the TMP75. There is some bitwise arithmetic in there, however if you are not keen on going down to that level, it is easy enough to cut and paste the temperature and numeric display functions.  Here is a quick video of the demonstration sketch in action:


So there you have it – another useful and educational shield for use with your Arduino. If you have any questions or enquiries please direct them to Gravitech via their contact page. Gravitech products including the 7-segment shield are available directly from their website or these distributors.

As always, thank you for reading and I look forward to your comments and so on. Furthermore, don’t be shy in pointing out errors or places that could use improvement. Please subscribe using one of the methods at the top-right of this web page to receive updates on new posts, follow on twitterfacebook, or join our Google Group.

[Disclaimer – the shield reviewed in this article was a  promotional consideration made available by Gravitech]

High resolution photos are available on flickr.

Posted in 24LC128, arduino, gravitech, I2C, LED, microcontrollers, product review, review, SAA1064, TMP75, tutorial0 Comments

Kit Review – Snootlab Rotoshield

Hello Readers

[Update: 11/12/11 – Added example code and video]

In this article we will examine yet another product from a bundle sent for review by Snootlab, a Toulouse, France-based company that in their own words:

… designs and develops electronic products with an Open Hardware and Open Source approach. We are particularly specialized in the design of new shields for Arduino. The products we create are licensed under CC BY-SA v3.0 (as shown in documents associated with each of our creations). In accordance with the principles of the definition of Open Source Hardware (OSHW), we have signed it the 10th February 2011. We wish to contribute to the development of the ecosystem of “do it yourself” through original designs of products, uses and events.

Furthermore, all of their products are RoHS compliant and as part of the Open Hardware commitment, all the design files are available from the Snootlab website.

The subject of the review is the Snootlab Rotoshield – a motor-driver shield for our Arduino systems. Using a pair of L293 half-bridge motor driver ICs, you can control four DC motors with 256 levels of speed, or two stepper motors. However this is more than just a simple motor-driver shield… The PCB has four bi-colour LEDs, used to indicate the direction of each DC motor; there is a MAX7313 IC which offers another eight PWM output lines; and the board can accept external power up to 18V, or (like other Snootlab shields) draw power from a PC ATX power supply line.

However as this is a kit, let’s follow construction, then explore how the Rotoshield could possibly be used. [You can also purchase the shield fully assembled – but what fun would that be?] Assembly was relatively easy, and you can download instructions and the schematic files in English. As always, the kit arrives in a reusable ESD bag:

There are some SMD components, and thankfully they are pre-soldered to the board. These include the SMD LEDs, some random passives and the MAX7313:

Thankfully the silk-screen is well noted with component numbers and so on:

All the required parts are included, including stackable headers and IC sockets:

It is nice to not see any of the old-style ceramic capacitors. The people at Snootlab share my enthusiasm for quality components. The assembly process is pretty simple, just start with the smaller parts such as capacitors:

… then work outwards with the sockets and terminals:

… then continue on with the larger, bulkier components. My favourite flexible hand was used to hold the electrolytics in place:

… followed with the rest, leaving us with one Rotoshield:

If you want to use the 12V power line from the ATX socket, don’t forget to bridge the PCB pads between R7 and the AREF pin. The next thing to do is download and install the snooter library to allow control of the Rotoshield in your sketches. There are many examples included with the library that you can examine, just select File > Examples > snootor in the Arduino IDE to select an example. Function definitions are available in the readme.txt file included in the library download.


After acquiring a tank chassis with two DC motors, it was time to fire up the Rotoshield and get it to work. From a hardware perspective is was quite simple – the two motors were connected to the M1 and M2 terminal blocks, and a 6V battery pack to the external power terminal block on the shield. The Arduino underneath is powered by a separate PP3 9V battery.

In the following sketch I have created four functions – goForward(), goBackward(), rotateLeft() and rotateRight(). The parameter is the amount of time in milliseconds to operate for. The speed of the motore is set using the Mx.setSpeed() function in void Setup(). Although the speed range is from zero to 255, this is PWM so the motors don’t respond that well until around 128. So have just set them to full speed. Here is the demonstration sketch:

… and the resulting video:

For support, visit the Snootlab website and customer forum in French (use Google Translate). However as noted previously the team at Snootlab converse in excellent English and have been easy to contact via email if you have any questions. Snootlab products including the Snootlab Rotoshield are available directly from their website. High-resolution images available on flickr.

As always, thank you for reading and I look forward to your comments and so on. Furthermore, don’t be shy in pointing out errors or places that could use improvement. Please subscribe using one of the methods at the top-right of this web page to receive updates on new posts, follow on twitterfacebook, or join our Google Group.

[Disclaimer – the products reviewed in this article are promotional considerations made available by Snootlab]

Posted in arduino, I2C, kit review, L293, MAX7313, microcontrollers, motor shield, product review, rotoshield, snootlab5 Comments

Review – Fluke 233 Remote Display True RMS Multimeter

Hello readers

Several followers of my website have noticed the use of an interesting multimeter in a few of my articles, and were curious about it. So in this article we will discuss it in more detail. It is certainly novel in design, and has proven to be very convenient in use – the Fluke 233 remote-display true RMS multimeter. It arrives in a cardboard box that is easily recycled:


Upon tearing open the packaging we are presented with the following contents:


The contents of the box are as follows:

  • The meter itself;
  • a long (~1.2m) pair of Cat IV leads with very sharp points;
  • matching insulated alligator clip adaptors;
  • a K-type thermocouple;
  • a printed Getting Started manual, and the complete manual on CDROM;
  • a single, universal getting started sheet – explains how to remove battery isolation tabs.

However, a carry case was not included. Considering the cost of the meter here (Au$550 + tax), one would have expected a case. On the other hand, if you/your workplace can afford a 233, you can pay for your own case. So there’s two angles to the case perspective.

It is good to see that there isn’t too much of a printer manual, the less paper used the better. As others have said, if you have one of these meters the manual isn’t necessary apart from checking the specifications, and the same applied to myself. Thoughtfully the meter is supplied and fitted with 5 x AA Duracell alkaline cells, three in the meter body and two in the display unit. All one needs to do is pull out the plastic tabs from the battery compartments, and you’re ready to go.

Physically the unit does not disappoint. Made in the USA. First class. Another solid Fluke design, clean lines, and a great fit and finish. Futhermore it is of a good weight, so you could always bang in a nail with it, or the pointy-head boss. The exterior has the rubber-moulded housing which is not removable, however this would be recommended for the target market – as the 233 would be more of a field work than a test-bench instrument. However, if you do sit it on the bench with the tilting bail, you can still operate it with one hand as it has enough friction to stay put. It is also good to see that the box and packaging are cardboard which is easily recycled.

After flicking the meter on the first thing to do was remove the display, plug in the thermocouple, and toss the body into the freezer:


Even with the meter in the freezer, I could still move the display around 1.5 meters away and it still received the data signal. Notice how the display is on the freezer door – it is magnetic. Immediately the benefits of the remote display come to mind. You can always have the display right where you want it, and the meter where it needs to be… it’s win-win. After showing it to my auto-electrician friend, she didn’t want to give it back.

The ability to set up a meter in a less than perfectly safe environment and take the display away is almost priceless. Furthermore, the backlight is a nice even blueish colour, and times out after around forty seconds. Whilst in the kitchen, I tested out the external temperature of my tea:


Using the meter in general is very simple, you can hold it in one hand and select all of the functions with your thumb. Having the yellow shift key makes changing between associated readings very simple, for example after reading AC voltage:


Then pressing the shift key changes to frequency:


The meter has several useful indication functions – while working with high voltages the triangular market is illuminated; when changing to temperature you are prompted with “OPEN” for the thermocouple, and changing to current you are prompted with “LEAD” to change sockets. It is obvious after a short period of time this was designed by engineers for engineers, and not made to a ‘price’. Although this is not an electronics multimeter, it still has quite a few ranges that would suit at a pinch. Plus the one-touch data hold, minimum and maximum functions are included as with other top-end Flukes. Hopefully someone at Fluke is working on a remote display version of their 87V.

Now that I have had this meter for just over five months, it has already become a worthwhile addition to my bench. For the kind of work I do, it has already replaced another multimeter, my old frequency counter and thermometer. The ranges are quite useful, and the continuity beeper is in the display not the body. According to the manual the 233 is rated for a one meter drop onto any of the six surfaces. Out of respect to the meter I will not throw it into a river or from a moving car. The other factor that prevents me from going to such extremes is the clear plastic over the LCD – there is a small amount of ‘give’ or flexibility in that area. Otherwise the 233 is as solid as they come.

The specifications can be found in detail in the manual here, however a quick glance shows:

Range                                                             Accuracy

AC voltage: 0.1mV ~ 1000V                      1~2%+3

AC current: 1mA ~ 10A                               1.5%+3

DC voltage: 0.1mV ~ 1000V                     0.25%+2

DC current: 1mA ~ 10A                               1.0%+3 ** no microamperes

resistance: 0.1 ~ 40 meg-ohm                   0.9~1.5%+2

frequency:  0.01 Hz ~ 50 kHz                    0.1%+2

capacitance: 1nF to 9999 uF                     1.9%+2

temperature: -40 ~ 400 degrees Celsius     1%+10

And there is also a diode test and continuity beeper function. Interestingly enough, I discovered by accident that the frequency counter function was slightly underrated. Some more testing showed it was good for up to 99.48 kHz:


Not bad at all. However as with the many pros, there are  a few cons to using this meter. The auto-zero time of the display is a little slow, sometimes it can take two seconds. That doesn’t sound like much, but when you’re measuring many components the time adds up. And the LCD is not protected as well as expected, you can push into it with your finger. For a Fluke meter, one would expect it to be much more solid – if the display unit fell from a height and landed on something pointy with the display facing down, it would be ruined. So be careful if you have one.

Furthermore, the battery life is around eight to ten weeks of “daily use” (perhaps seven hours a week, usually with the backlight on). Some have said this is bad, however my opinion is that the convenience of the remote display makes up for the shorter battery life.

However at the end of the day – this is a great tool. Being able to measure something outside your field of vision, and having the results in front of you is incredibly useful. You could achieve the same functions by using a meter with a PC interface, but that can be overkill and time-consuming to set up. So if the specifications of the 233 meet your needs, this is a great tool that will serve you very well.

The Fluke 233 Remote Display True RMS Multimeter is available from your local element-14 or Fluke distributor.

As always, thank you for reading and I look forward to your comments and so on. Furthermore, don’t be shy in pointing out errors or places that could use improvement. Please subscribe using one of the methods at the top-right of this web page to receive updates on new posts. Or join our Google Group.

[Disclaimer – the Fluke 233 is a review sample made available by Fluke via element-14]

Posted in 233, fluke, learning electronics, product review, test equipment6 Comments

Initial review: mbed LPC1768 Development Board

In this article we review the mbed NXP LPC1768 development board and the mbed system in general.


Today we will examine the mbed NXP LPC1768 development board. The goal of the mbed system is to “provide(s) a platform for microcontroller hardware, tools, libraries and resources designed to enable rapid prototyping with microcontrollers.” ( Personally I also see this as a good option for a “next step” for those who have outgrown their Arduino – the mbed offers much more processing power, a similar development environment and similar hardware ease of use. A great way to move from 8-bit to 32-bit power…

The NXP LCP1768 MCU on our mbed board offers the following specifications:

  • a Cortex-M3 core running at 96MHz
  • 512kb flash memory and 64kb RAM
  • powered via USB or 4.5~9V DC applied straight to the board
  • Real time clock (requires external battery backup if necessary)
  • Loads of I/O options, including:
  • USB serial
  • I2C
  • Ethernet on board
  • SPI
  • serial I/O
  • Control-area network (CAN) bus
  • 3.3v digital logic, 40mA per digital pin with a total maximum of 400 mA
  • analog and digital I/O pins

For a full description and data sheet, please visit:

Although a small project started by two ARM employees, the mbed has proven to be a worthy product to allow people of generally all skill levels access to powerful microcontrollers without a lot of the inherent complications. It does this in two ways:

Firstly, the hardware is very simple and designed for ease of use. The LPC1768 is mounted on a small board to convert it to a DIP format, making breadboard easy. The designers have also thought to include four blue LEDs for digital output and a nice large reset button. Interface with the PC is via USB. The mbed appears as a USB flash drive to your computer’s operating system, and compiled programs are downloaded as a single .bin file into the mbed.

Secondly, the development environment. Unlike other MCU products on the market, mbed is a completely online development environment. That is, in a manner very similar to cloud computing services such as Google Docs or Zoho Office. However there are some pros and cons of this method. The pros include not having to install any software on the PC – as long as you have a web browser and a USB port you should be fine; any new libraries or IDE updates are handled on the server leaving you to not worry about staying up to date; and the online environment can monitor and update your MCU firmware if necessary. However the cons are that you cannot work with your code off-line, and there may be some possible privacy issues. We will examine the online environment later on.

Preparing and using the mbed is incredibly simple. The designers have certainly exceeded their goal of providing a rapid prototyping environment. The process from opening the box to running your first program is (as always) quite simple.

The initial packaging is clear and inviting, and includes a getting started document, USB cable, a laminated hardware pinout card (very useful) and a bumper sticker (!):



The mbed unit itself is compact yet not too small:


The underside contains the USB interface and flash drive controllers:


The initial setup requires registration with the mbed online environment. This is done by plugging in your mbed to the USB, and visiting the web page URL stored in the mbed’s flash drive:


This will take you to the login page where you can create a new user profile:


The serial number of the mbed is recognised and linked to your user account. This means you do need to own an mbed to explore the depths of the online services available, and also serves to keep the mbed online ecosystem free of spammers and whatnot. After registration, you will be presented with the “getting started” page, which contains links to the function references, tutorials, FAQs, user forums, user-contributed content and more. All is revealed by exploring the links from this page.

After signing up, you can create a profile page which is public. This also contains tabs that contain notes, published (programs you make public) and libraries (that you have made public) Initially I thought the profile page would be private, or limited to other mbed owners, but this is not the case. From this page you can create notebook files, view your past activity and display published programs and libraries.

For example, I created a test notebook page and someone left a comment on it twenty minutes later. So be careful if you have some secrets – instead, you could cut and paste work to and from the IDE. However if you accidentally publish something it can be deleted, but remember that the internet is written in ink, not pencil.

However don’t let privacy worries put you off – just be careful not to write anything or publish programs you want to keep secret. Furthermore, as said earlier –  having an online IDE has a few advantages – you don’t need to install anything on your PC apart from an up to date web browser. This means you can work on programs from other computers with ease. Bored at work? Using a locked-down hotel or  school computer? You can still work on your mbed programs!

The openness of the mbed environment does create a positive, helpful environment similar to that found in the open-source community – there are many libraries that have been submitted that allow connection to various pieces of hardware such as LCD screens, bluetooth, Wii controllers, motors, servos, sensors and so on – as well as libraries for pachube, twitter, HTTP client and server access, and much more. These are found in the environment’s “Cookbook” section. If something interesting is on the market, there may very well be an mbed library to work with it.

The IDE is quite clear and straightforward. The program editor maintains colour-context, line numbering, support auto-formatting, and you can import or export code using the standard copy and paste keyboard shortcuts.


You can have multiple folders open at once, where each folder contains one program, the standard mbed function library and others you may have imported. Furthermore, there is also a very clear function reference for the standard mbed library available within the IDE – very useful. Programs are written in C++, and the online IDE takes care of everything – leaving you with only the .bin file to upload to the mbed. If you are new to programming or a little rusty with C++, books with unfortunate titles such as “C++ for Dummies” may prove useful.


You can also import libraries published by other mbed users into your own projects. Details of these published libraries (and programs) are listed in the mbed online environment. The speed of development is demonstrated very well in this video from the mbed team:

The support options are very good, including a members-only forum, loads of information, the Cookbook, a wiki for publishing user-contributed libraries and resources, and other FAQs and so on. If you have a question I am sure it could be answered very quickly.  When it comes time to compile and run your program, after a successful compile your computer will download a single .bin file, which is then copied over to your mbed. Then by pressing the reset button on the mbed, the program is stored into the MCU and executed. You can store more than one .bin file on the mbed, however the latest file (by time stamp) is only executed.

Overall the mbed is a refreshingly-easy point of entry to microcontrollers. The ability to quickly prototype an idea into reality is really not difficult, and those with some C++ experience (or willing to learn) will make use of the mbed environment in no time at all. And if you decide to move your prototype into production, details and schematics are provided to help implement the nxp LPC1768 into your designs. Frankly, for fast prototyping at work, or just fun for anyone interested in electronics, the mbed offers a simple yet powerful way of getting things done.

The mbed board used in this review was a promotional consideration from RS. You can purchase an mbed directly from your local RS distributor.

In the meanwhile have fun and keep checking into 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.

Posted in learning electronics, lesson, LPC1768, mbed, microcontrollers, product review, review, tronixstuff, tutorial10 Comments

Kit Review – Alan Parekh’s Infra-Red Jammer

[Updated 17/01/2013]

In this review we examine another kit which goes hand in hand with other mischievous items such as the TV-B-Gone – the Infra-Red Jammer kit by Alan Parekh of The function of this product is to create infra-red signals that are stronger than those from a normal remote control, thereby rendering it useless. Our jammer sends the signal out using four high-output infra-red LEDs, on the following frequencies: 30, 33, 36, 38, 40 and 56 kHz.

This is controlled by a small MCU that is included in preprogrammed form with the kit, so you don’t need to do it yourself. However, if you are building a jammer from scratch, Alan does allow the download of the hex file to program your own. However, please note that this kit is not an open-source hardware, so you cannot just start knocking out your own. But enough talking, let’s get building!

The kit is packaged in the typical minimalist fashion, the parts inside an anti-static bag:


Upon turfing out the contents, we find them to be:


Unlike most other kit suppliers, I was very happy to see the IC socket included. It probably cost about 10 cents, but it can save someone a whole day of mucking about if they aren’t the best at soldering, and don’t have an electronics store nearby. Furthermore the PCB is solder-masked and silk screened nicely, and is of a decent thickness. Once again – if smaller companies can offer kits with such great PCBs, why cannot larger multi-million dollar outfits like Jaycar offer such great PCBs in their kits? Grrr. Anyway.

The assembly instructions have been compiled into a very neat and tidy book that is downloadable as a .pdf file. It is very clear and easy to follow, great for beginners or enthusiasts alike. So at this point it’s time to get soldering.

At first you need to decide upon the power output strength which is determined by R1 and R2 – for me, it’s all or nothing so I went for the high-power resistors. Thankfully values to use three output levels are included, so you will have some spare resistors at the end. Once those are in, the rest of the assembly is relatively straight forward:


What did take me be surprise is the length of the leads on the two electrolytic capacitors – they were very short. This made mounting them difficult:


However with a little perseverance they went in and stayed put. Although the jammer is activated for thirty seconds by pressing the button as seen in the photo above, there are also two pads on the PCB for another button… so you could, for example, mount the jammer under a lounge or inside an object, and have the button wired remotely. Very good idea:


They are visible between the diode and the press button. Finally it was time to plug in a 9V battery and start jamming. Interestingly enough the PCB size matches the profile of a typical PP3 9V battery, so if you insulated the PCB with tape or another material, you could mount the PCB onto the battery:


As decided earlier, I chose the highest power output setting by using the low values for R1 and R2. At this point I was curious as to how much current the jammer will draw while operating – which turned out to be 209 mA:


So bear this in mind if you are going to spend the day jamming up things. You might want to carry a spare battery, or wire a couple up in parallel. But now it was time to get jamming and have some fun. The check of the infra-red LEDs was successful:


A test at home showed it knocked out all the IR receivers on my sound and video gear from a distance of around 5 metres. I couldn’t try any further as a wall was in the way, but with the unit set to high power I’m sure it should be good for around fifteen metres at least.

Now when you press the button, the jamming will run for thirty seconds. However you can increase this by buffering up more presses – for example if you press the button three times the jammer will run for ninety seconds. If you were in a trade show, or somewhere you needed to create some mayhem, build a TV-B-Gone and one of these jammers. Turn off the screen then setup your jammer for a couple of minutes. You will drive the presenters positively nuts. Awesome!


This is another fun and inexpensive kit that can be used for hours on end in various situations. It was easy to solder apart from a couple of capacitors, and getting them in wasn’t really a problem once you held them in with some blu-tac. So if you’re looking for a gift for some trouble-makers, or just want to stop people changing the channel during the cricket, this kit is for you. It is available directly from Alan’s website here: and is a steal for less than US$20 delivered.

In the meanwhile have fun and keep checking into 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.
[Note – this kit was a promotional consideration made available by Alan Parekh]

Posted in infrared, jammer, kit review, product review0 Comments

Review – Ikalogic SCANALOGIC2 Logic Analyser/Signal Generator

Hello Readers

Today we will take a first look at the Ikalogic “Scanalogic2” PC-based logic analyser and signal generator. This is a tiny and useful piece of test equipment that should be useful for beginners and experienced engineers alike. It has been developed by two guys in Europe that are dedicated to the craft, and I wish them well. First of all, let’s pull it out of the box and see what we have:


Upon opening the box, one finds a USB cable, the connector leads and the unit itself. It really is small, around 60 x 35 x 20mm. The USB cable is just under 900mm long. Finally a small instruction and welcome postcard which details a quick overview of the software and the unit’s specifications. Ikalogic are to be congratulated for the minimal level of packaging – finally a company that realises one can download the required items instead of printing books, burning DVDs and causing an increase in shipping weight.

The first thing you will need to do is download the latest software. It needs a Windows-based PC with .net framework. Installing took about two minutes, then the ubiquitous system restart. Finally the last preparation is to check for the latest firmware and update it. This is a simple procedure – download a .zip file, extract the .hexe file, then just file>update device firmware in the software. The desktop software checks for new versions before every startup, so you can be sure of having the latest version.

Here are the specifications of the unit from their web page:


Certainly there is a lot there to take advantage of. Personally I consider the logic analyser functions to be of great interest, and will now demonstrate those to see how they can be useful in debugging and generally figuring out what my designs are up to.

One can capture data in two ways, either by using a live sampling mode, or capture mode where you set the device to sample data into its memory, and then reviewing the data using the software. If you are using the live mode, the quality of the sampling will be affected by your PC resources. For example, consider this first demonstration. A very simple Arduino is setting a pin high and low:


In live mode you can still use the horizontal scroll feature to move backwards and forwards through the captured data. One can also expand the data display to the full width of the window. When using the live mode, I found that there was still some variation in the logic levels that was not programmed for. My PC is fairly up to date, consisting of an AMD PhenonII dual-core 3.1 GHz CPU, 2GB RAM at 1066 MHz, running Windows 7 x64. Perhaps I could use some more RAM? A better video chipset? Who knows… Unfortunately I don’t have a more powerful PC to test. Therefore I will stick to the normal capture mode. Doing so is also quite easy – here is the basic setup tab:

It is pretty self-explanatory. If you have a fair idea of your sampling rate, you can drop it down to increase the available sampling time. Here I have selected the lowest sampling rate, as I will just capture the pulses as shown in the earlier demonstration. Once your sample has been collected, you can scroll through it at your leisure, and also save the sample to disk.

In being able to save the data for later retrieval, there are three things that can be done with the data:

  1. As anyone can download the software, you can share your samples by emailing or sharing the files with colleagues – they can playback the sample without owning a Scanalogic themselves, by just using the software;
  2. You can keep the sample for later analysis
  3. You can blast out the captured data using the function generator feature. Neat! Let’s do that now…

Earlier on I captured the following from an Arduino board:


And now I can just right-click on the data (channel one) and select run data generator for this channel then click start on the left. Which results in the following output:

Very good (except for my old CRO). Also notice the log area at the bottom of the application screen – it relays unit status, error messages and so on. Now let’s capture and look at some more interesting sample data. The following example is an example of captured data from an Arduino serial-out pin, which was programmed to send the letter “A” out at 2400 bps using serial.write();


Once you have captured the sample, you can select the parameters of the data stream and decode the sample. As you can see in the image above, the decoder shows the data stream in hexadecimal and the ASCII equivalent.

Next on the test is I2C. This is a common two wire data bus from Philips/NXP, used in many systems. More about I2C with Arduino is here. A very popular example of an I2C IC is the Maxim DS1307 real-time clock. We can use our Scanalogic to eavesdrop on the SCA and SCL data lines to see what is being said between the microcontroller and the DS1307:


So in the example above, the value 0x68 (binary 1101000) is sent down the bus. This is the unique identifier (slave address) for a DS1307 IC. So the Arduino is saying “Hey – DS1307 – wake up”. This is then followed by a 0x00 or directional bit. The DS1307 then replies by sending the time data back to the bus. The first piece of data in the reply is 0x68, which identifies to the I2C bus (recall that 0x68 is the DS1307 identifier) that the data is from the DS1307. Following this is the time and data data in hexadecimal, which is converted to binary-coded decimal in the microcontroller software.

When working with I2C, it really pays to have the data sheet for your IC with you. Then you can decipher the data, direction and timing with the sample data on one side and the timing diagrams on the other. For example, page twelve of the DS1307 data sheet. In doing so, it reminds me how much I dislike I2C 🙂

Moving along. Next we will have a look at some data from the SPI (serial peripheral interface) lines. Again, this is quite simple, you just connect the four hooks into the clock, MOSI, MISO and CS lines, and capture away. The software allows you to select which hook is connected to which line, so you can connect up quickly. At this point I will note that the IC hooks are somewhat inexpensive, and the designers could have spent a few more Euro on including some decent ones. Anyhow, here is the screen dump:


At this point one can realise all sorts of monitoring possibilities. I wish I had one of these years ago when learning digital electronics – you could just monitor the highs and lows over four channels and debug things very quickly. Will keep this in mind when I get around to making a TTL clock.

Anyhow – the Scanalogic2 has a lot going for it in terms of data capturing ability, the price is right, you can update the software and firmware very easily, and the desktop software is freely available in order to share samples with others. There are a few cons though – the IC hooks could be better (I couldn’t connect four in a row onto an IC for the life of me); the unit could use some documentation in terms of a “Getting Started” guide or webpage – so due to this the learning curve is quite high. There is their version here, but I feel it could be expanded upon. Many beginners and amateurs will be attracted to this unit due to the price. However there is a support forum and so on, but answers can vary in quality and time. However, don’t let the cons put you off – this thing is cheap, the software is very good – and it works. Two thumbs up!

To purchase a Scanalogic2, visit the Ikalogic home page. If you need to analyse some data, and don’t want to spend a bucket of money – this is for you.

Posted in ikalogic, product review, review, Scanalogic, test equipment4 Comments

Part review – Batsocks Tellymate Arduino Shield

Hello readers

Every once in a while you have an idea for something that is quite simple in theory, yet complex to implement. Once example of this in my opinion is getting information from your Arduino to the outside world. Sure you can use an LCD, lots of LEDs, use a servo as an analogue meter, etc., but one of the best ways would be to a simple video monitor or TV. Imagine the possibilities that are available if your Arduino project could display data on a simple television screen – suddenly you could commercialise  projects and/or really have some fun.

Well now this is all possible with the Batsocks Tellymate Arduino shield! Sweet. Let’s check it out:



The developers have really made this simple. You just connect it like any other shield, run the included cable from the shield’s socket to the “video in” on the TV or monitor. The shield uses digital pins 0 and 1. There are also seven hard-wired jumpers that you can use to select carriage return attributes, PAL/NTSC output, and so on:



From a software point of view, it is also quite simple to use. Just insert Serial.begin(57600); into void setup(); and you’re away. Just use Serial.write(); or Serial.print(); and it will send the data off to the TV. It can support a resolution of 25 rows by 38 columns. Not the greatest, but for the price it does what it is designed to do. For normal use it supports the characters from code page 437, which for the older readers will look very familiar.

Sending other commands to the Tellymate is done with codes sent to it. For example, to clear the screen is ” E”. But that is not the command. Thankfully the manufacturer’s website has a detailed range of instructions and examples that you can work with to make the most out of it. Personally I just printed out the pages and made my own reference manual, which works well.

To get you up and running quickly, here is a brief sketch that is quite easy to follow. It is the temperature logger sketch from my Arduino tutorial modified to display via the Tellymate. Here is the sketch: sketch.pdf, and a video of it operating.

Unfortunately it is difficult to record the display as we  have a CRT television, but I hope you get the idea. My next example is to recreate the binary quiz game from Chapter Five of my Arduino tutorial. Again, not too difficult. The main caveat is (as usual) to plan before programming. And this proved to be a better rendition of the game – here is the sketch:

… and some screen shots:








And the video:

As you can see it is quite versatile with normal text and characters. Considering it costs under US$40, the Tellymate is quite the problem-solver. You can also define your own characters, for example to create your own symbols or game characters. Furthermore, larger fonts sizes are available (double height and width) and they can mix on the same screen with regular-sized characters. So now you have a better understanding of the Tellymate. High resolution photos are available on flickr. And if you made it this far – check out my new book “Arduino Workshop” from No Starch Press.

In the meanwhile have fun and keep checking into 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.

[Note – this product was purchased by myself personally and reviewed without notifying the manufacturer]

Posted in arduino, batsocks, part review, product review, tellymate0 Comments

Subscribe via email

Receive notifications of new posts by email.

The Arduino Book

Arduino Workshop

Für unsere deutschen Freunde

Dla naszych polskich przyjaciół ...

Australian Electronics!

Buy and support Silicon Chip - Australia's only Electronics Magazine.

Use of our content…

%d bloggers like this: