Tag Archive | "adafruit"

Tutorial – Arduino and TFT Color Touch Screen

Learn how to use an inexpensive TFT colour  touch LCD shield with your Arduino. This is chapter twenty-nine of our huge Arduino tutorial series.

Updated 07/02/2014

There are many colour LCDs on the market that can be used with an Arduino, and in this tutorial we’ll explain how to use a model that is easy to use, has a touch screen, doesn’t waste all your digital output pins – and won’t break the bank. It’s the 2.8″ TFT colour touch screen shield from Linksprite:

Arduino TFT colour touch shield front

And upside down:

Arduino TFT colour touch shield back

As you can imagine, it completely covers an Arduino Uno or compatible board, and offers a neat way to create a large display or user-interface.  The display has a resolution of 320 x 240 pixels, supports up to 65536 colours and draws around 250mA of current from the Arduino’s internal 5V supply. 

And unlike other colour LCDs, this one doesn’t eat up all your digital output pins – it uses the SPI bus for the display (D10~D13), and four analogue pins (A0~A3) if you use the touch sensor. However if you also use the onboard microSD socket more pins will be required. 

With some imagination, existing Arduino knowledge and the explanation within you’ll be creating all sorts of displays and interfaces in a short period of time. Don’t be afraid to experiment!

Getting started

Setting up the hardware is easy – just plug the shield on your Arduino. Next, download the library bundle from here. Inside the .zip file is two folders – both which need to be copied into your …\Arduino-1.0.x\libraries folder. Then you will need to rename the folder “TFT_Touch” to “TFT”. You will notice that the Arduino IDE already contains a library folder called TFT, so rename or move it.

Now let’s test the shield so you know it works, and also to have some quick fun. Upload the paint example included in the TFT library – then with a stylus or non-destructive pointer, you can select colour and draw on the LCD – as shown in this video. At this point we’d like to note that you should be careful with the screen – it doesn’t have a protective layer.

Afraid the quality of our camera doesn’t do the screen any justice, however the still image looks better:

Arduino TFT colour touch shield paint demonstration

Using the LCD 

Moving on, let’s start with using the display. In your sketches the following libraries need to be included using the following lines before void setup():

… and then the TFT library is initialised in void setup()

Now you can use the various functions to display text and graphics. However you first need to understand how to define colours.

Defining colours

Functions with a colour parameter can accept one of the ten ten predefined colours – RED, GREEN, BLUE, BLACK, YELLOW, WHITE, CYAN, BRIGHT_RED, GRAY1 and GRAY2, or you can create your own colour value. Colours are defined with 16-but numbers in hexadecimal form, with 5 bits for red, 6 for green and 5 for blue – all packed together. For example – in binary:

These are called RGB565-formatted numbers – and we use these in hexadecimal format with our display. So black will be all zeros, then converted to hexadecimal; white all ones, etc. The process of converting normal RGB values to RGB565 would give an aspirin a headache, but instead thanks to Henning Karlsen you can use his conversion tool to do the work for you. Consider giving Henning a donation for his efforts.

Displaying text

There are functions to display characters, strings of text, integers and float variables:

In each of the functions, the first parameter is the variable or data to display; x and y are the coordinates of the top-left of the first character being displayed; and colour is either the predefined colour as explained previously, or the hexadecimal value for the colour you would like the text to be displayed in – e.g. 0xFFE0 is yellow.

The drawFloat() function is limited to two decimal places, however you can increase this if necessary. To do so, close the Arduino IDE if running, open the file TFTv2.cpp located in the TFT library folder – and search for the line:

… then change the value to the number of decimal places you require. We have set ours to four with success, and the library will round out any more decimal places. To see these text display functions in action,  upload the following sketch:

… which should result in the following:

Arduino TFT colour touch shield text

To clear the screen

To set the screen back to all black, use:

Graphics functions

There are functions to draw individual pixels, circles, filled circles, lines, rectangles and filled rectangles. With these and a little planning you can create all sorts of images and diagrams. The functions are:

The following sketch demonstrates the functions listed above:

… with the results shown in this video.

Using the touch screen

The touch screen operates in a similar manner to the other version documented earlier, in that it is a resistive touch screen and we very quickly apply voltage to one axis then measure the value with an analogue pin, then repeat the process for the other axis.

You can use the method in that chapter, however with our model you can use a touch screen library, and this is included with the library .zip file you downloaded at the start of this tutorial.

The library does simplify things somewhat, so without further ado upload the touchScreen example sketch included with the library. Open the serial monitor then start touching the screen. The coordinates of the area over a pixel being touch will be returned, along with the pressure – as shown in this video.

Take note of the pressure values, as these need to be considered when creating projects. If you don’t take pressure into account, there could be false positive touches detected which could cause mayhem in your project.

Now that you have a very simple method to determine the results of which part of the screen is being touched – you can create sketches to take action depending on the touch area. Recall from the example touch sketch that the x and y coordinates were mapped into the variables p.x and p.y, with the pressure mapped to p.z. You should experiment with your screen to determine which pressure values work for you.

In the following example, we don’t trigger a touch unless the pressure value p.z is greater than 300. Let’s create a simple touch-switch, with one half of the screen for ON and the other half for OFF. Here is the sketch:

What’s happening here? We divided the screen into two halves (well not physically…) and consider any touch with a y-value of less than 160 to be the off area, and the rest of the screen to be the on area. This is tested in the two if functions – which also use an and (“&&”) to check the pressure. If the pressure is over 300 (remember, this could be different for you) – the touch is real and the switch is turned on or off.

… and a quick demonstration video of this in action.

Displaying images from a memory card

We feel this warrants a separate tutorial, however if you can’t wait – check out the demo sketch which includes some example image files to use.

Conclusion

By now I hope you have the answer to “how do you use a touch screen LCD with Arduino?” and had some fun learning with us. And if you enjoyed the tutorial, or want to introduce someone else to the interesting world of Arduino – check out my book “Arduino Workshop” from No Starch Press. Finally, thanks to Linksprite for their support.

 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.

Posted in arduino, LCD, Linksprite, TFT, touch screen, tronixstuff, tutorial

Review – adafruit industries Mini 8×8 LED Matrix with I2C backpack

Introduction

In this review we have a look at the mini 8×8 LED matrix with I2C backpack from adafruit industries. It looked like a small yet versatile display unit for a couple of project ideas, so as part of the evaluation we’ll run through it with you here. As you can see below, it’s quite small with a 20mm square matrix:

contents

The matrix and the controller are seperate which gives you the option of ordering different colours of matrix. Using LED matrices can be a pain, however these units use the Holtek 16K33 controller IC (data sheet) which has an I2C interface – much easier than the usual mess of shift registers and I/O pins:

holtek

 Furthermore you can change the I2C address using the solder pads on the PCB, giving you four possible options. And as it’s I2C, you can use it with other microcontrollers with a little detective work. Moving forward, we’ll assemble the display then explain how to use it with an Arduino, and show a few demonstrations.

Assembly

There really isn’t anything major to do, just solder the matrix to the backpack and some header pins if you need them. adafruit include some however I’m using the 90-degree ones for my own use:

solderingpins

The soldering should take about one minute tops, and then you’re done:

finished

Using the matrix

From a hardware perspective you only have four wires – 5V, GND, SDA and SCL. Yes – it’s a 5V part, so all you Raspberry Pi fans will need a level shifter, which you can get from adafruit as well. Anyhow once you’ve got it connected to your Arduino, a couple of libraries are required – the matrix and GFX libraries. Be sure to install them in your sketchbook/libraries folder and not the usual location. When saving the library files, call the first folder Adafruit_LEDBackpack and the second Adafruit_GFX as they don’t arrive in that format.

Now for a quick demonstration, it’s simply one from the included library. The display is very bright, so I had to reduce the exposure on the camera which makes the background a little dark – but you get the idea:

A pair of those fitted to a dummy or doll would be quite interesting, or make good eyes for a 21st century “Metal Mickey”. Well that’s quite interesting, so how do you in fact display things on the matrix? I’ve deconstructed a few examples to show you how it’s done.

No matter what, you need to include the libraries, define the matrix object in the sketch and then start it with the matching I2C address – for example:

To scroll text across the display, modify the following chunk of code:

First, the setRotation() value is 0~3 and determines which way the text scrolls across the screen. This is useful if you mount the matrix in different positions, as you can still keep the text scrolling in a readable manner. Next, matrix.setTextWrap() – leave this as false,  as true displays each character and then just scrolls it in turn – looking rather odd. Now multiply the number of characters you want to display by 8, and replace the number -96 with negative your value and of course “Hello, world”. Finally follow with rest of the code. There’s a quick demonstration of this code in the sketch and video below:

 

Now for some graphics. You can define your own images (!) and store them in an array. Each arrays consists of eight bytes, each representing a row of the matrix. You can use binary to help visualise the results, for example:

and then to display that on the matrix, use the following:

… which resulted with:

crosshatch

To control individual pixels, send one or more of the following:

where x and y are the pixel’s coordinates (that fall between zero and seven), followed by:

Here’s a neat example sketch and video of a single pixel “running around the border”:

By this point you should be getting the hang of things now, so we’ll finish up with the last three graphic functions at once. To draw a line between x1, y1 and x2, y2 – use:

To draw a rectangle with corners at x1, y2, x2, y2 – use:

To draw a filled rectangle with corners at x1, y2, x2, y2 – use:

And to draw a circle with axis at x,y and a radius of r pixels – use:

Now we’ll put those functions into the following sketch and video:

 

If you want to get someone’s attention, you can blink whatever’s on the matrix at various frequencies – and of course turn it off. In the following function, use 0 for off, and 1~3 for different rates:

Finally, you can also adjust the brightness to one of sixteen levels (0~15) using:

That’s enough blinkiness for now. Remember the library is just shielding you from the raw I2C commands, so if you want to create your own functions or use a non-Arduino board – examine the library and the data sheet.

Conclusion

The backpack makes using the matrix an absolute breeze, and the library saves a lot of time and effort – leaving you to get on with creating your ideas into projects. You can get the matrix from adafruit and their distributors.

Full-sized images 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 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.

[Note - item purchased without notifying the supplier]

Posted in 16K33, adafruit, arduino, holtek, I2C, LED matrix, review, tutorialComments (0)

Clock Kit Round-up – December 2011

Hello Readers

If there’s one thing that I really like it’s a good clock kit. Once constructed, they can be many things, including:

  • a point of differentiation from other items in the room;
  • a reminder of the past (nixie tubes!) or possible visions of the future;
  • the base of something to really annoy other people;
  • a constant reminder to get back to work;
  • a source of satisfaction from having made something yourself!

So just for fun I have attempted to find and list as many interesting and ‘out of the ordinary’ kits as possible, and ignored the simple or relatively mundane kits out there. If you are in the clock kit business and want a mention, let me know. So in no particular order, we have:

adafruit industries “ice tube” clock

Based around a vintage Soviet-era vacuum IV-18 type fluorescent display, the ice tube clock is a rare kit that includes a nice enclosure which keeps you safe from the high voltages as well as allowing the curious to observe your soldering skills. I reviewed this kit almost a year ago and the clock is still working perfectly. Here is a video of the ice tube clock in action:

After some travelling meeting various people it seems that quite a few of us have an ice tube clock. There is something quite mesmerising about the display, perhaps helping to recall memories of our youth in the 1970s and 80s.

nootropic design Defusable Clock Kit

As recently reviewed, this kit allows you to build a simulated ‘countdown’ timer for a hypothetical explosive device that also doubles as a clock with an alarm. For example:

Whatever you do, don’t make a ‘fake bomb’ and leave it out in public! Only bad things could happen :)

ogilumen nixie tube kits

Not a clock kit as such, however they have made doing it yourself very easy with their power supply and IN-12A nixie board kits. We made one ourselves in a previous review, as shown below:

Alan Parekh’s Multimeter Clock Kit

This is certainly one from left field – using the analogue multimeters to display hours, minutes and seconds. See Alan describe his kit in this video:

Certainly something different and would look great on the wall of any electronics-themed area or would easily annoy those who dislike the status-quo of clock design.

akafugu VFD Modular Clock

The team at akafugu have created a modular baseboard/shield kit which holds a shield containing four IV-17 alphanumeric nixie tubes to create your own clock or display system:

vfd-7

Unlike some of the other nixie tube kits the firmware has been made public and can be modified at will. In the future different display shields will be available to extend the use of the kit.

tubeclock.com kits

This site has two kits available, one using either four or six Soviet-era IN-12 type nixie tubes:

large_red

… and another kit using the Soviet-era IN-14 nixie tubes:

You have to hand it to the former Soviet Union – they knew how to over-produce nixie tubes. One rare example where we can benefit from a command economy!

evil mad science clocks

The certainly not evil people have two clock kits, the first being the Bulbdial Clock Kit:

This uses a unique ring of LEDs around the circumference of the clock face to create shadows to mark the time. It is also available in a range of housing and face styles. Their other kit of interest is the Alpha Clock Five:

The photo of this clock doesn’t do it justice – the alphanumeric displays are 2.3″ tall, making this one huge clock. It also makes use of a Chronodot real-time clock board, which contains a temperature-controlled oscillator  which helps give it an accuracy of +-/ 2 minutes per year. Furthermore you can modify this easily using an FTDI cable and the Arduino IDE with some extra software. Would be great for model railways (or even a real railway station) or those insanely conscious about the time.

Kabtronics Clock Kits

This organisation has several clock kits which span a range of technology from the later part of the twentieth century. These guys can only be true clock enthusiasts! Starting with the 1950s, they have their Nixie-Transistor Clock:

neononwall

Look – no integrated circuits, leaving the kit true to the era. If you need to hide from someone for a weekend, building this would be a good start. Next we move onto the 1960s and the Transistor Clock:

onwall_l

The 1960s brought with it LEDs so they are now used in this kit, however the logic is still all analogue electronics. However next we can move to the 1970s, and finally save some board space with the TTL Clock:

ttlclock_1721

This would still be fun to assemble but somewhat less punishing for those who don’t enjoy solder fumes that much. However you still have a nice kit and something to be proud of. Finally, the last in the line is the 1980s-themed Surface-Mount Technology Clock:

smtclock_l

So here we have a microcontroller, SMT components, and a typical reduction in board size. Their range is an excellent way of demonstrating the advances in technology over the years.

The GPS FLW Display Clock

Wow – this clock makes use of huge Burroughs B7971 15-segment nixie tube displays and a GPS receiver to make a huge, old-style/new-tech clock. Check out the demonstration video:

This thing is amazing. And it is actually cheaper to buy a fully-assembled version (huh). The same organisation also offers another GPS-controlled clock using IN-18 nixie tubes:

nixichron10

Again, it isn’t inexpensive – however the true nixie tube enthusiasts will love it. This clock would look great next to a post-modern vintage hifi tube amplifier. Moving forward to something completely different now, we have the:

adafruit industries monochron®

Almost the polar opposite of the nixie-tube clocks, the monochron uses an ATmega328 microcontroller and a 128 x 64 LCD module to create some interesting clock effects. For example:

Many people have created a variety of displays, including space invaders and the pong game simulation. The clock also includes the laser-cut acrylic housing which provides a useful and solid base for the clock.

Spikenzie Labs Solder : Time™ watch kit

Technically this is a watch kit, however I don’t think that many people would want to walk around wearing one – but it could be used in more permanent or fixed locations. Correct me if I’m wrong people. However in its defence it is a very well designed kit that is easy to solder and produces a nice clock:

It uses a separate real-time controller IC to stay accurate, and the design However this would be a great suggestion as a gift for a younger person to help them become interesting in electronics and other related topics. The asm firmware is also available for you to modify using Microchip MPLAB software if that takes your fancy.

Velleman Kits

The Velleman company has a range of somewhat uninspiring clock kits, starting with the Scrolling/Rolling LED Clock:

… the 2¼” 7-Segment Digital Clock:

This clock includes the housing and also accepts an optional temperature sensor, and therefore can display this as well. There is also the aptly-named – Digital LED Clock:

mk151

It tells the time and would be useful in a 1980s-era idea of the future movie set. The final velleman clock kit is the Jumbo Single-Digit Clock:

In all fairness this one looks quite interesting – the LED display is 57mm tall and the time is display one digit at a time. It is powered by a PIC16F630 however the firmware is proprietary to velleman.

Nocrotec Nixie Clocks

This company has a range of kits using nixie tubes and numitrons (low voltage incadescent displays in tubes). One particularly lovely kit is their IN-8 Blue Dream kit:

in-8-bd-h-side-blue

The blue glow at the base of the nixie tubes is due to an LED mounted at the bottom of the tube. Another aesthetically-pleasing kit is their Little Blue Something nixie clock. Check out their demonstration video:

nixiekits.eu

More IN-12 nixie clocks from Germany, the first being the Manuela_HR. You can buy the kit without an enclosure, or choose from the ‘office’ style:

… or this funky number:

You can specify it with RGB LEDs which colour-cycle to provide the effect shown above. For those not too keen you can also buy the kits pre-assembled. Their other kit is the Sven:

Sven_IN-8-2_720

It is available with IN-8 or IN-14 nixie tubes. The design quality of the enclosure is outstanding, a lot of effort has been made to produce a complete kit that “won’t look like a kit” when completed.

Minty Time

This is a small binary clock kit that fits in an Altoids tin:

This is a nice little kit as it is inexpensive, easy to make and very well documented. You could also mount this in a variety of flat surfaces, limited only by your imagination.

The Chronulator

Here we find a unique design that uses analogue panel meters in a similar method to the multimeter clock detailed previously. Here is an example of the completed kit:

IMG_1113

The kit contains the electronics and meters (or you can delete the meters for a discount if you already have some) however the housing is up to you. Furthermore, this kit has some of the best instructions (.pdf) I have ever seen. They are a credit to the organisation. Our final clock kit is the …

Denkimono

This is another clock kit in the style of ‘suspicious bomb timer’-looking – and it pulls this off quite well. Consider the following video demonstration:

As well as a normal clock it can function as an alarm, stopwatch, countdown timer and lap counter. The instructions (.pdf) are well written and easy to follow. Furthermore the Denkimono is also well priced for the kit and delivery.

Hopefully this catalogue of clock kits was of interest to you. If you have found some other kits to add to the list, or wish to disagree or generally comment about this article please do so via the comment section below. This article was not sponsored in any way.

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.

Posted in clocks, kit review, nixie, review, TTL, VFDComments (8)

Tutorial: Arduino and monochrome LCDs

Please note that the tutorials are not currently compatible with Arduino IDE v1.0. Please continue to use v22 or v23 until further notice. 

This is chapter twenty-four of a series originally titled “Getting Started/Moving Forward with Arduino!” by John Boxall – A tutorial on the Arduino universe.

The first chapter is here, the complete series is detailed here.

Welcome back fellow arduidans!

The purpose of this article is to summarise a range of affordable monochrome liquid-crystal display units that are available to work with our Arduino; and to replace the section about LCDs in chapter two of this series. We will first examine some fixed-character and then graphical LCD units in this article. So let’s go!

Fixed-character LCD modules

When shopping around for LCD modules, these will usually be the the most common found in retail outlets. Their size is normally measured by the number of columns and rows of characters in the display. For example, the three LCDs below are 8×2, 16×2 and 20×4 characters in size:

lcdtypesss

Currently, most LCDs should have a backlight of some sort, however you may come across some heavily-discounted models on (for example) eBay that are not. Character, background and backlight colours can vary, for example:

backlitsss

Interfacing these screens with our Arduino boards is very easy, and there are several ways to do so. These interface types can include four- and eight-bit parallel, three-wire,  serial, I2C and SPI interfaces; and the LCD price is usually inversely proportional to the ease of interface (that is, parallel are usually the cheapest).

Four-bit parallel interface

This is the cheapest method of interface, and our first example for this article. Your LCD will need a certain type of controller IC called a Hitachi HD44780 or compatible such as the KS0066. From a hardware perspective, there are sixteen pins on the LCD. These are usually in one row:

16pinsss

… or two rows of eight:

2by8pinsss

The pin labels for our example are the following:

  1. GND
  2. 5V (careful! Some LCDs use 3.3 volts – adjust according to LCD data sheet from supplier)
  3. Contrast
  4. RS
  5. RW
  6. Enable
  7. DB0 (pins DB0~DB7 are the data lines)
  8. DB1
  9. DB2
  10. DB3
  11. DB4
  12. DB5
  13. DB6
  14. DB7
  15. backlight + (unused on non-backlit LCDs) – again, check your LCD data sheet as backlight voltages can vary.
  16. backlight GND (unused on non-backlit LCDs)

As always, check your LCD’s data sheet before wiring it up.

Some LCDs may also have the pinout details on their PCB if you are lucky, however it can be hard to decipher:

Now let’s connect our example 16×2 screen to our Arduino using the following diagram.

Our LCD runs from 5V and also has a 5V backlight – yours may differ, so check the datasheet:

4bitparallel2

(Circuit layout created using Fritzing)

Notice how we have used six digital output pins on the Arduino, plus ground and 5V. The 10k ohm potentiometer connected between LCD pins 2, 3 and 5 is used to adjust the display contrast. You can use any digital out pins on your Arduino, just remember to take note of which ones are connected to the LCD as you will need to alter a function in your sketch. If your backlight is 3.3V, you can use the 3.3V pin on the Arduino.

From a software perspective, we need to use the LiquidCrystal() library. This library should be pre-installed with the Arduino IDE. So in the start of your sketch, add the following line:

Next, you need to create a variable for our LCD module, and tell the sketch which pins are connected to which digital output pins. This is done with the following function:

The parameters in the brackets define which digital output pins connect to (in order) LCD pins: RS, enable, D4, D5, D6, and D7.

Finally, in your void setup(), add the line:

This tells the sketch the dimensions in characters (columns, rows) of our LCD module defined as the variable lcd. In the following example we will get started with out LCD by using the basic setup and functions. To save space the explanation of each function will be in the sketch itself. Please note that you do not have to use an Arduino Mega – it is used in this article as my usual Arduino boards are occupied elsewhere.

And here is a quick video of the example 24.1 sketch in action:

There are also a some special effects that we can take advantage of with out display units – in that we can actually define our own characters (up to eight per sketch). That is, control the individual dots (or pixels) that make up each character. With the our character displays, each character is made up of five columns of eight rows of pixels, as illustrated in the close-up below:

pixels

In order to create our characters, we need to define which pixels are on and which are off. This is easily done with the use of an array (array? see chapter four). For example, to create a solid block character as shown in the image above, our array would look like:

Notice how we have eight elements, each representing a row (from top to bottom), and each element has five bits – representing the pixel column for each row. The next step is to reference the custom character’s array to a reference number (0~7) using the following function within void setup():

Now when you want to display the custom character, use the following function:

where 0 is the memory position of the character to display.

To help make things easier, there is a small website that does the array element creation for you. Now let’s display a couple of custom characters to get a feel for how they work. In the following sketch there are three defined characters:

And here is a quick video of the example 24.2 sketch in action:

So there you have it – a summary of the standard parallel method of connecting an LCD to your Arduino. Now let’s look at the next type:

Three-wire LCD interface

If you cannot spare many digital output pins on your Arduino, only need basic text display and don’t want to pay for a serial or I2C LCD, this could be an option for you. A 4094 shift register IC allows use of the example HD44780 LCD with only three digital output pins from your Arduino. The hardware is connected as such:

twilcd

And in real life:

exam24p3ss

From a software perspective, we need to use the LCD3Wire library, which you can download from here. To install the library, copy the folder within the .zip file to your system’s \Arduino-2x\hardware\libraries folder and restart the Arduino IDE. Then, in the start of your sketch, add the following line:

Next, you need to create a variable for our LCD module, and tell the sketch which of the 4094′s pins are connected to which digital output pins as well as define how many physical lines are in the LCD module. This is done with the following function:

Finally, in your void setup(), add the line:

The number of available LCD functions in the LCD3wire library are few – that is the current trade-off with using this method of LCD connection … you lose LCD functions but gain Arduino output pins. In the following example, we will demonstrate all of the available functions within the LCD3Wire library:

And as always, let’s see it in action. The LCD update speed is somewhat slower than using the parallel interface, this is due to the extra handling of the data by the 4094 IC:

Now for some real fun with:

Graphic LCD modules

(Un)fortunately there are many graphic LCD modules on the market. To keep things relatively simple, we will examine two – one with a parallel data interface and one with a serial data interface.

Parallel interface

Our example in this case is a 128 by 64 pixel unit with a KS0108B parallel interface:

glcdparallelss

For the more technically-minded here is the data sheet. From a hardware perspective there are twenty interface pins, and we’re going to use all of them. For breadboard use, solder in a row of header pins to save your sanity!

This particular unit runs from 5V and also has a 5V backlight. Yours may vary, so check and reduce backlight voltage if different.

You will again need a 10k ohm potentiometer to adjust the display contrast. Looking at the image above, the pin numbering runs from left to right. For our examples, please connect the LCD pins to the following Arduino Uno/Duemilanove sockets:

  1. 5V
  2. GND
  3. centre pin of 10k ohm potentiometer
  4. D8
  5. D9
  6. D10
  7. D11
  8. D4
  9. D5
  10. D6
  11. D7
  12. A0
  13. A1
  14. RST
  15. A2
  16. A3
  17. A4
  18. outer leg of potentiometer; connect other leg to GND
  19. 5V
  20. GND

A quick measurement of current shows my TwentyTen board and LCD uses 20mA with the backlight off and 160mA with it on. The display is certainly readable with the backlight off, but it looks a lot better with it on.

From a software perspective we have another library to install. By now you should be able to install a library, so download this KS0108 library and install it as usual. Once again, there are several functions that need to be called in order to activate our LCD. The first of these being:

which is placed within void setup(); The parameter sets the default pixel status. That is, with NON_INVERTED, the default display is as you would expect, pixels off unless activated; whereas INVERTED causes all pixels to be on by default, and turned off when activated. Unlike the character LCDs we don’t have to create an instance of the LCD in software, nor tell the sketch which pins to use – this is already done automatically. Also please remember that whenever coordinates are involved with the display, the X-axis is 0~127 and the Y-axis is 0~63.

There are many functions available to use with the KS0108 library, so let’s try a few of them out in this first example. Once again, we will leave the explanation in the sketch, or refer to the library’s page in the Arduino website. My creative levels are not that high, so the goal is to show you how to use the functions, then you can be creative on your own time. This example demonstrate a simpler variety of graphic display functions:

Now let’s see all of that in action:

You can also send normal characters to your KS0108 LCD. Doing so allows you to display much more information in a smaller physical size than using a character  LCD. Furthermore you can mix graphical functions with character text functions – with some careful display planning you can create quite professional installations. With a standard 5×7 pixel font, you can have eight rows of twenty-one characters each. Doing so is quite easy, we need to use another two #include statements which are detailed in the following example. You don’t need to install any more library files to use this example. Once again, function descriptions are in the sketch:

Again,  let’s see all of that in action:

If you’re looking for a very simple way of using character LCD modules, check this out.

LEDborder

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.

Posted in arduino, education, LCD, LCD-00710, learning electronics, lesson, microcontrollers, tutorialComments (58)

Kit Review – adafruit industries Ice Tube clock v1.1

Hello readers

Today we examine a kit that perhaps transcends from general electronic fun and games into the world of modern art – the adafruitIce Tube” clock.

What is an Ice Tube clock? Before LCDs (liquid-crystal displays) were prevalent another form of display technology was popular – the vacuum-fluorescent display (or VFD). This clock uses a VFD originally manufactured in the former Soviet Union (link for the kids) or Russia (I think mine is date-stamped January 1993). This particular VFD contains a series of seven-segment digits and a dot, which allow the display of time in a bright and retro fashion.

Since this kit was released I had always desired one, however my general parsimonious traits and the wavering exchange rate against the US dollar kept my spending in check. But lately my wallet was hit by a perfect storm: the Australian dollar hit parity with the greenback, adafruit had a discount code and I felt like spending some money – so before the strange feelings passed I ordered a kit post-haste.

Sixteen slow, hot days later the box arrived. I must admit to enjoying a good parcel-opening:

packagingss

As always, the packaging was excellent and everything arrived as it should have. But what was everything?

boxcontentsss

Included is the anti-static bag containing the PCB and general components, a bag with the laser-cut acrylic pieces to assemble the housing, another bag with the housing fasteners and the back-up coin cell for the clock, a mains adaptor, and finally another solid cardboard box containing the classic display unit – albeit with the following sensible warning:

warningss

And finally the Russian IV-18 display tube:

tuberulerss

The tube is a fascinating piece of work, certainly a piece of perfect retro-technology and a welcome addition to my household. Assembling the clock will not be a fast process, and in doing so I recommend reviewing the detailed instructions several times over at the adafruit website. Furthermore, it is a good idea to identify, measure and line up the components ready for use, to save time and confusion along the way. Your experience may vary, however this kit took around three hours for me to construct.

Normally with most kits you can just solder the components in any order, however it is recommended you follow the instructions, as they are well written and allow for testing along the way. For example, after installing the power regulator, you can check the output:

firsttestss

At this stage, you can test your progress with the piezo beeping at power-on:

pcb2ss

These mid-construction tests are a good idea as you can hopefully locate any problems before things get out of hand. Another item to be careful with is the PLCC socket for the Maxim MAX6921 VFD driver IC (second from the left):

pcb3ss

However with time and patience there is no reason why you would have any problems. Once the main PCB is completed, the next item is the end PCB which connects to the VFD:

endpcbss

At this point it is a good time to have a break and a bit of a stretch, as you need all your patience for soldering in the VFD. Before attempting to do so, try and carefully straighten all the wires from the VFD so they are parallel with each other. Then using the adafruit instructions, make sure you have the tube wires lined up with the correct hole on the PCB:

endpcb2ss

After I had the leads through the correct holes on the PCB, trimming the leads made things easier:

endpcb3ss

It is also a good idea to check the gap between the VFD and the PCB is correct, by checking the fit within the housing:

testfitss

And after much patience, wire pulling with pliers, and light soldering –  the VFD was married to the PCB:

endpcb4ss

So now the difficult soldering work has been completed and now it was time for another test – the big one… does it all work?

alivess

Yes, yes it does. *phew* The low brightness is normal, as that is the default level set by the software. Please note: if you run your VFD without an enclosure that you must be careful of the high voltages on the right-hand side of the PCB and also the VFD PCB. If you test your VFD in this manner, don’t forget to allow ten minutes for the voltage to return to a safe level after removing the power supply. If you have been following the instructions (I hope so!) there is some more soldering to do, after which you can put away your soldering iron.

Now to remove the liner from the acrylic housing pieces and put it all together. Be very careful not to over-tighten the bolts otherwise you will shatter the housing pieces and be cranky. If all is well, you’re finished clock will appear as such:

tothisss

The clock in use:

runningss1

And finally, our ubiquitous video demonstration:

VFDs can lose their brightness over the years, and can be difficult to replace – so if you want many, many years of retro-time it would be smart to buy an extra tube from adafruit with your kit, or a modified DeLorean.

Overall, this was an interesting and satisfying kit to assemble. Not for the beginner, but if you have built a few easier kits such as  the “TV-B-Gone” with success, the Ice Tube clock will be within your reach. Furthermore, due to the clear housing, this kit is a good demonstration of your soldering and assembly skills. High resolution images are available on flickr.

You can purchase the kit directly from adafruit industries. 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.

[Note - The kit was purchased by myself personally and reviewed without notifying the manufacturer or retailer]

Posted in adafruit, clocks, ice tube clock, IV-18, kit review, VFDComments (3)

Kit Review – adafruit industries mintyboost v3

Hello readers

Today we are going introduce another useful kit from adafruit industries – their mintyboost kit. The purpose of this kit is to provide a powered USB socket suitable for charging a variety of devices, powered from a pair of AA cells. The mintyboost is quite a simple, yet clever design – the latest version is based around the Linear Technology LT1302 DC/DC step-up converter that we examined a few months ago - and can provide a full 5 volts DC at 500 milliamps, enough to charge the latest round of USB-chargable gadgets, including those iPhones that I keep hearing about. And unlike an iPhone, the mintyboost kit is licensed under a Creative Commons v2.5 attribution license.

But enough reading, time to make it. As always, instructions are provided online – are easy to follow and very clear. The kit will arrive in a nice reusable anti-static bag:

bagss1

Which contains everything you need except for AA cells and a housing:

partsss5

Where or how you contain your mintyboost is a subjective decision, and will probably vary wildly. The original design brief was to have it fit inside a tin that Altoids confectionary is sold in, however those are not available around my area. But I found a suitable replacement. The PCB is very small, and designed to fit snugly inside the aforementioned tin:

pcbss2

Very small – less than 38 x 20 mm in dimension. However with some care and caution, you can solder the components without using a vice or “helping hands”. Though if you have access to these, use them as it will make life a lot easier. Before we move on, please note that my 49.9k ohm resistors, ceramic capacitors and the inductor are a different size to those included with the kit. This is my second mintyboost, and to save money I bought the PCB only and used my own parts to make this one.

If size is an issue for you, it is a good idea to buy the entire kit, as you will have resistors that fit flush with the PCB, unlike mine :)

resiscapsss1

However, construction moved along smoothly, by following the instructions, double-checking my work and not rushing things. There is some clever designing going on here, I have never seen a resistor underneath an IC socket before!

sockss

But when PCB real estate is at a premium, you need think outside of the box. After this stage there was just the electrolytic capacitors and battery holder to install. One that has been done, you can insert some fresh AA cells and check the output voltage on the USB lines:

5vss

Looking good, however it could have been a bit higher if the AA cells were freshly charged. But the second USB voltage was spot on:

1p9vss

Success! It always feels good to make a kit and have it work the first time. The last soldering was to take care of fitting the USB socket, and then it was finished:

barefinishedss

Now to take it for a test run. I have two USB-charging items to test it with, my HTC Desire:

htcss

The LED to the right of the htc logo indicates the power is in, and the battery indicator on the left of the clock indicates charging. Excellent. The phone battery is 1400 mAh – I most likely won’t get a full recharge from the two AA cells, but enough to get me through an extra night and half a day. The mintyboost is a perfect backup-charging solution to leave in your backpack or other daily case. And now for something from Apple, an iPod of about four years old (it still holds a charge, so I’m not falling for the “buy a new iPod every twelve months” mantra):

ipodss

Again, perfect. Apple equipment can be quite finicky about the voltages being fed to them, and will not work if there is a slight difference to what the device expects to be fed. As you can see the team at adafruit have solved this problem nicely. There is also much discussion about various devices and so on in their support forums.

Now for the decision with regards to housing my mintyboost. The Altoids tins are not an option, and I’m not cannibalising my mathematical instruments storage tin. But I knew I kept this tin for a reason from last February:

contentsss

Plenty of room for the PCB, the charging cable, emergency snack cash and even more AA cells if necessary. And where else could I have put the socket, but here:

rearendss

:) I have named it the bunnyboost:

bunnyboostss

… who can safely live in the bottom of my backpack, ready to keep things powered at a moments’ notice. Excellent!

As you can see, the mintyboost is a simple, yet very practical kit. It would also make a great gift for someone as well, as USB-charging devices are becoming much more popular these days. If you are looking to buy a kit, those of you in the Australasian market can get one from Little Bird Electronics, or globally available from adafruit industries. High resolution photos are available on flickr.

Once again, thank you for reading and I look forward to your comments and so on. Please subscribe using one of the methods at the top-right of this web page to receive updates on new posts, and if you have any questions – why not join our Google Group? It’s free and we’re all there to learn and help each other.

[Note - this kit was purchased by myself personally and reviewed without notifying the manufacturer or retailer]

Posted in adafruit, kit review, LT1302, mintyboostComments (6)

Kit Review – adafruit industries waveshield kit

Hello readers

Today we are going introduce another useful kit from adafruit industries – their waveshild Arduino shield kit. The purpose of this shield is to play audio files sourced from a computer, at the request of an Arduino sketch. It is an interesting product in that it meets one of the needs of the original concept of Arduino, that is:

… It’s intended for artists, designers, hobbyists, and anyone interested in creating interactive objects or environments. (arduino.cc)

Yes – yes indeed. For a while I had seen this kit, and though that there wasn’t much point to it. But if you spend a few moments contemplating how the control of sounds or recorded voice could be used, suddenly you have a “light bulb moment” and come up with all sorts of things, both crazy and sensible.  Once again, this kit arrives in typical adafruit packaging, a simple reusable antistatic bag:

bagss

and emptying the contents onto the desk reveals the following:

partsss2

And before anyone asks me, no the parts don’t arrange themselves as they fall out of the bag. If they did, we’d have some much larger problems in the world. At first glance I was worried that not all of the parts had been included, however this is kit version 1.1, and there will be empty spaces on the PCB. Speaking of which, once again it is a nice thick, solder-masked and nicely silk screened PCB.

The pre-assembly checklist, assembly instructions and all other documentation and required software links can be found on the adafruit website. After checking off the included parts against the adafruit bill of materials, it was time to start. You will need a few extra things, for example a speaker if necessary, an SD memory card (up to one gigabyte in size) – and in my case two 8-pin IC sockets. When you live in an area where finding specialised ICs is difficult or just time-consuming, IC sockets are very cheap insurance.

The first item to solder in is the SD card, and this is a surface-mount part. But don’t let that worry you, it ‘clicks’ into the PCB, and you then just hold it down with one hand while holding some solder, and with the other hand heat each pad for two seconds and let some solder flow over the pads:

smd_sdss

And you don’t need to solder in the last three, narrower contacts of the reader – they are not used. Everything else is standard through hole, nothing much to worry about apart from burning yourself while listening to the radio. Except for one resistor, R6 – the one next to IC4. If you solder in the resistor first, even though it sits normally – it is about one millimetre too close to the IC. So if you are going to assemble this, solder in IC4 before R6:

resisprob

However it isn’t anything to panic about, just something to keep an eye out for. Moving forward, everything else went in easily:

gettingtheress

The last basic soldering to take care of is the expansion pins for the shield to able to mate with other shields. The easiest way to solder these in is to first drop the new pins into an existing, matching board – as such:

pinsbeforess

Then drop the waveshield on top of the pins and solder away:

almostfinishedss

And finally, some links from the circuit to the digital pins… Then lo and behold, we’re finished:

finishedss3

During the initial testing and experimenting, I was going to use a set of earphones to listen to the output, however instead ended up installing a small 0.25 watt 8 ohm speaker. The solder pads for the speaker are between the rear of the headphone socket and C9. If you decide to use both headphones and a speaker, the circuit is designed in such a way as the headphone socket will cut off the speaker when headphones are in use. adafruit also sell the waveshield party pack which includes a memory card and speaker to save you shopping around.

Note that this shield will need digital pins 2~5 and 10~13 – as noted in Jon Oxer’s new website – shieldlist.org.

Now that the hardware has been taken care of, let’s get our Arduino talking and grooving. The first thing to do is install the wavehc library into your Arduino IDE software. The library and related buffering use a fair amount of memory, so if you are running an Arduino with the old ’168 MCU, it’s time to find the $6 and upgrade to the ATmega328.

Next, visit the tronixstuff file repository. Download the waveshieldtest.pde sketch; and also download this audio file onto the SD card. Finally, insert the SD card, upload the sketch, insert your headphones and the board should play the file. Don’t forget to turn the volume up a little, yours may be set to off by default.

Now that we know it is working, it is time to examine how we can control things in more detail. The most important thing is to have your .wav sound files in the correct format. The maximum sampling rate is 22 kHz, depth of 16-bit, and in mono PCM format. You can download an open-source audio editor package to do the conversions for you here. ladyada has also written a good conversion tutorial for you here.

Apart from converting audio files for playback, if you want to get some backchat you will need to find a speech-synthesiser. You can make use of the AT+T Labs Natural Voices (R) Text to Speech demo website for this. Just enter some text, and then you can download the .wav file:

att_speechss

Now let’s have a quick look at how we can play files on demand, to let our own projects make some noise. Please download the sketch waveshieldtest2.pde. Although there is a large amount of code in there, what we’re interested in is just the void loop(); function. To play a .wav file, such as “wisdom.wav”, just use

So you can just mash that sketch and your own code together to get some files playing, however don’t forget your attributions to the original authors. Here is a … longer demonstration of waveshieldtest2.pde:


You can purchase the waveshield kit directly from adafruit industries.  High resolution images are 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. Or join our Google Group.

[Note - The kit was purchased by myself personally and reviewed without notifying the manufacturer or retailer]

Posted in adafruit, arduino, kit review, microcontrollers, tutorial, waveshieldComments (11)

Kit Review – adafruit industries DS1307 Real Time Clock breakout board kit

Hello readers

Today we are going to examine another small yet useful kit from adafruit industries – their DS1307 Real Time Clock breakout board kit. My purpose of acquiring this kit was to make life easier when prototyping my clock and timer Arduino-based projects on a breadboard. For example, blinky, or the various clock projects in the Arduino tutorials.

When breadboarding a DS1307 circuit, there are a few problems – the legs of the crystal are very fine, and break easily, and trying to mount the backup battery holder on the breadboard can be difficult due to their odd pin-spacing. That is why this breakout board is just perfect for breadboarding. Finally, (in Australia anyway) the price of the kit is less than the sum of the retail cost of the parts required. Anyhow, time to get cracking!

Again, as usual the adafruit kit packaging is simple, safe and reusable:

bagss2

And with regards to the contents within:

partsss

… no surprises here, another quality solder-masked, silk-screened PCB  that has everything you need to know printed on it. Now that you can see the crystal (above image, bottom-right) you can realise why this board is a good idea. Furthermore, the inclusion of a quality battery and not some yum-cha special is a nice touch.

Assembly is incredibly simple. The IC position is printed on the PCB, the resistors are the same, and the capacitor and crystal are not polarised. Again, no IC socket, but perhaps it is time not to worry about that anymore – my soldering skills have improved somewhat in the last twelve months. Plus the DS1307 can handle 260 degrees Celsius for ten seconds when soldering (according to the data sheet.pdf).

However if you like to read instructions (which is generally a good idea) the excellent documentation is laid out here for your perusal.

Soldering the board is quite straightforward, however when it comes time to solder in the coin cell holder, note that there are large gaps in the mounting holes:

1ss

It is important to solder the pins solidly to the PCB, without letting lots of solder flow through the hole and block the other side. If you can bend the pins slightly closer to the circumference of the hole, soldering will be a lot easier. And don’t forget to put a blob of solder on the top-facing pad between the two pin holes before soldering in the coin cell holder.

Finally, when time to solder in the header pins, mount the lot onto a breadboard, and support the gap between the PCB and the breadboard at the opposite end of the PCB. An old CD works very well:

2ss

And within ten minutes of starting, we have finished!

3ss1

Insert the backup cell (writing facing up!) in the holder and you’re ready to time. A new backup cell should last between seven to ten years, so unless you want to reset the clock completely, leave the cell in the board.

Now it is time to use the board. My only experience is with the Arduino-based systems, and even so using the DS1307 can seem quite difficult at the start. However with the right library and some basic reusable sketch modules you can do it quite successfully. The board is a standard DS1307 circuit, and is explained in great detail within the data sheet.pdf.

Don’t forget you can get a nice 1 Hz (or 4, 8 or 32 kHz) square wave from this IC – here is a sketch that allows you to control the square-wave generator:

And a video demonstration:

Well I hope you found this review interesting, and helped motivate you to expand your knowledge and work with real-time clocks, Arduino and the I2C bus.

You can purchase the kit directly from adafruit industries.

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 new Google Group. High resolution images are available on flickr.

[Note - The kit was purchased by myself personally and reviewed without notifying the manufacturer or retailer]

Posted in adafruit, ds1307, kit review, microcontrollers, real time clock, tutorialComments (6)

Kit Review – adafruit industries XBee adaptor kit

Hello readers

Today we are going to examine a small yet useful kit from adafruit industries – their XBee adaptor kit. The purpose of doing so was to save some money. How? I needed another XBee USB explorer board to connect a PC to an XBee (as we have done in Moving Forward with Arduino – Chapter Fourteen), but they are around Au$33. However I already have an FTDI USB cable, so all I really need is this kit, as it will work with the FTDI cable. So this saves me around $20.

As usual the adafruit kit packaging is simple, safe and reusable:

bagss1

The components included are good as usual, including a great solder-masked, silk-screened PCB and an excess of header pins. Got to love a bonus, no matter how small:

componentsss

This did not take very long to assemble at all. After checking the parts against the parts list, it was time to fire up the iron and solder away. As usual the kit is almost over-documented on the adafruit web pages. But that is a good thing…

gettingtheress

Be careful when you place R3, make sure it doesn’t lean in towards the end of the IC too much, otherwise they could touch, or even worse – stop the IC from being seated properly:

closeicresistorss

Regular readers will know I get annoyed when IC sockets are not included with kits – but for the first time it is fine with me. If you use a socket, the IC will be elevated too much and stop the XBee from being inserted onto the board. But apart from R3 almost stopping the show, everything went smoothly. At the time you need to solder in the 2mm header socket strips for the XBee, the easiest way (if possible) is to seat an XBee in the sockets, then into the PCB:

2mmheadersss

Once you have followed the excellent instructions, the last thing to solder is the pins for the FTDI cable. You can either lay them out flat on the PCB, or insert them through the holes. This is my preferred way, and seating the lot in a breadboard to hold it steady is a good idea:

endheadersss

And finally, we’re finished:

finishedss

A quick check with Windows to ensure everything is OK:

And we are ready for communications. This was a very simple and inexpensive board to assemble – and excellent value if you need USB connection to your PC and you already have an FTDI cable.

Well I hope you found this review interesting, and helped you think of something new to make with XBees. You can purchase the kit directly from adafruit industries.

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 new Google Group. High resolution images are available on flickr.

[Note - The kit was purchased by myself personally and reviewed without notifying the manufacturer or retailer]

Posted in adafruit, kit review, part review, WRL-08687, xbeeComments (2)

Kit Review – adafruit industries TV-B-Gone

[Updated 17/01/2013]

In this review we examine an easy to build kit from adafruit industries that offers literally hours and hours of fun, if you like to get up to some mischief – the TV-B-Gone. This fascinating little device is basically an infra-red remote control for televisions and some monitors. It has a microcontroller programmed with the “off” code for a wide range of display brands, and four very strong infra-red transmitting LEDs, two with a wide beam, and two with a narrow but longer beam.

Here is the little culprit in standard assembled form:

11

It is a very easy kit to assemble, once again the team at adafruit have published an extensive amount of information, from assembly tutorials to how it works, and even the design itself as the kit is open-source hardware. So in this article you can follow the assembly, and use of this bag of fun.

As usual, this kit arrives in a resealable, anti-static bag. After ensuring I had the correct parts, from the documentation on the adafruit website, it was time to follow the simple instructions and start getting it together. Now this will be the second time I have built a TV-B-Gone… the first one is in the photo above, and had me removed from a department store (thanks Myer…) – so this time I am rebuilding it to fit inside a typical baseball cap.

Soldering it was quite simple, the PCB is solder-masked and has a very well detailed silk-screen:

21

Just following the instructions, and being careful not to rush is the key. Another feature of adafruit kits is that the are designed very well with regards to troubleshooting. For example, you have the opportunity to test it before finishing. So at this stage you can fit the AA cells and power it up, if the LED blinks you’re all good:

3s

And we’re done… almost.

4s

For installation into the hat, the button and the LEDs will need to be a distance away from the PCB. At this stage I was not sure where to put the button, so for now it can stay on the side of the cap:

5s

Naturally you can use any momentary push button, however I will use the included example (above) with a length of wire. With this style of hat, especially a black one, slight bulges underneath the surface do not seem that apparent, however it is wiser to spread out the entire unit:

6s

Although thinner AAA cells could be used for the power supply, for a good day’s action you will want the extra capacity of AA cells, so we’ll stick with them for now. The next step was to wire up the LEDs. They were connected individually to the PCB with lengths of wire, and heatshrink was used to insulate and darken the legs:

7s

 

8s

9s

And finally the finished product, ready for insertion into a piece of clothing, or in our case – a cap:

10s

At this point it was time to take it for a test toast. The quickest way to test an infra-red transmitter is to look at the LEDs through a digital camera – it can display the infra-red wavelengths whereas the human eye cannot see them. For example:

Those LEDs can get very bright (in infra-red terms), and is also how night-illumination for digital security cameras work. If you had a lot of those LEDs pointing at a security camera at night, you could blind it. That gives me an idea…

Anyway…

Assembling the kit in this format gives you lots of options for hiding it. For example, you could:

  • put the PCB and power in a jacket’s inside pocket, and have the LEDs poke out the neck;
  • place them in a cap as we are;
  • use a large ladies’ handbag, with the LEDs out the top, and the button underneath a handle;
  • sew the LEDs into the head-cover of a hooded jacket (with some longer leads) and have the PCB, power and button in the pockets

So here are the LEDs mounted under the brim of the cap:

11s

If you are going to staple them in, be careful not to puncture the wires. The ends of the staple should come through to the top of the brim – in this case I covered them with black ink from a felt pen so they would blend in. The button lead’s position is down to personal preference, in my case the button is just poking out next to the strap on the back of the cap. So all I need to do is appear to scratch the back of my head to activate the TV-B-Gone.

And here is the finished product, with an unfinished author:

Well by now you want to see it working. So here you are… I went on a field trip wandering about the central business district of Brisbane, Australia:

My apologies for the shaky footage, doing this isn’t something you can really capture with a camera and a tripod. :) The problem was getting close enough, or most places had either covered their IR receiver, had a brand of TV not recognised by the TV-B-Gone, or used a large monitor instead of a television. But it was fun nevertheless.

In conclusion, this is an easy to assemble kit which is fun and certainly will get you into harmless trouble. Again, this is the type of kit that would be good for those who are being introduced to the fascinating world of electronics (etc) as it is quick to build, and does something with the “real world”  that young people love so much. Or anyone else for that matter.

As much fun as it is to switch off televisions and advertising monitors, I would hope that end users will still be responsible with their TV-B-Gone use. Please head into a department store, your favourite eatery, coffee shop or mall and switch off the TVs.  However, please do not turn off displays in railway stations, airports or other places where the authorities will take offence. You will get in real trouble. Or if you’re feeling suicidal, go switch off the TVs at the OTB.

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.
[Note - this kit was purchased by myself personally and reviewed without notifying the manufacturer or retailer]

Posted in adafruit, kit review, learning electronics, tv-b-goneComments (13)

Kit review – adafruit industries Game of Life

[Updated 17/01/2013]

In this review we examine the Game of Life kit from adafruit industries. This kit is simple to construct, yet interesting to watch in operation, almost mesmerising. If you love blinking LEDs, this is the kit for you. Furthermore, it is very easy to construct which makes it a great kit for someone who is learning to solder. But before we run through putting it together, what is the Game of Life?

In 1970, a mathematician by the name of John Conway created the concept of the Game of Life, which is a example of a cellular automaton. Imagine a grid of cells, and each cell can either be dead or alive. Each cell interacts with the cells around it, and these neighbouring cells determine the life of the cell that they are neighbours to. There are a few simple rules to this:

  • a live cell with less than two neighbours will die, due to under-population;
  • a live cell with more than three neighbours will die, due to overcrowding;
  • a live cell with two or three neighbours lives on;
  • a dead cell with three neighbours will come to life, due to regeneration.

For example, consider the following situations:

cells

1 – death; 2 – life; 3 – death; 4 – life; 5 – rebirth; 6 – death. This kit displays a simulation of the Game of Life process using a 4 x 4 grid of LEDs. Once you start watching the kit in operation, you often try to predict what will happen next. So, let’s assemble it and see what happens.

As usual, adafruit ship their kits in reusable anti-static bags:

1

Upon opening it up and turfing out the contents, we are presented with the following:

2

Everything is included to make the kit operational – no surprises. I scored an extra green LED – thanks! The kit can operate from between 3 and 5 volts, hence the 2 x AA cell holder included. The PCB is of excellent quality, with strong solder masking and a very descriptive silk screen:

3

This really is a simple kit to assemble. All the resistors are identical, so you can insert them into the board and solder them all in once hit. Time to fire up the iron and the fume extractor…

4

Careful when clipping off the excess leads, they can fly all over the place!

5

Next for the IC socket. Good to see a socket was provided:

6

At this point I would like to mention that all the documentation for the kit, instructions, schematic, code for the microcontroller – everything – is available freely, as this is an open source kit. If you intent to make your own, or modify the original design, you must respect the terms of the original Creative Commons licence as detailed in the documentation. Moving on, time for the capacitor and the link. The original design used an LM7805 regulator to control the incoming power supply, however this version (1.3) can operate from 3 to 5V, so an LDO isn’t needed. Therefore a link is placed between pins 1 and 3 of the regulator’s spot on the PCB:

7

Also note that there are three spaces for capacitors, but only one is necessary – solder it into the space for C3. I put it into C2 by accident, but luckily this is acceptable for the design, and I had some spares in the stock here. Now it is time for the LEDs. The kit ships with green LEDs, which look fine. My original plan was to solder in snap-off pin sockets so I could change the LEDs over at a whim, but none in stock. So on with the green! For visual appeal they look good flush with the PCB, as such:

8

and in with the rest:

9

Almost finished, time to solder in the power/reset button and we’re done:

10

Hooray – the main work is done. The six holes on the left of the IC are for in circuit programming, but I’m an arduidan at the moment, so will leave that alone. The IC is already programmed before it leaves for the outside world, so you don’t have to worry about it. Next was to test the board and make sure it worked. I loosely connected 5V and hit the power button:

11

Looking good. Now for the power supply. Although it can run from 2 x AA cells, mine will just sit on the desk. Last month I bought a few USB extension cables for $1 each, so I can just chop one up and use it to power the GOL from my PC. The first thing to do in this case is separate the wires in the cable, and determine which is which:

13

Luckily for me this cable had the power lines appropriately colour coded. However, one should always check, so I plugged it into the PC and set the meter on the black and red wires:

12

5.04 volts DC – close enough for me. I soldered in the lead, and also screwed in some spacers to act as support legs so the kit will stand up on its own. And as a long-term temporary measure, a great wad of blutac to hold the wire and keep the pressure off the joints:

14

Hey, it works for me. Anyhow, the assembly is finished. Time to clean the desk off, put the soldering iron somewhere safe to cool off, and wash my hands. The whole lot took just under one hour, including checking the news website every now and then. It has a place just next to my PC:

15

To operate the GOL is very simple, once power is applied, hold down the button to turn it on and off. Then you can reset the cells with a quick press if you are bored with the pattern. Here is a video of it in action:

So there you have it – another successful kit build. This was a lot of fun, I enjoyed learning about John Conway and his theories, and enjoy watching the display. If you are feeling adventurous you can actually connect these kits together to form larger, blinkier games of life. Details of this and other things is available in the kit’s documentation pages. So get one, have fun with it, or give it to someone else to get them interested in electronics.

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.

[Note - this kit was purchased by myself personally and reviewed without notifying the manufacturer or retailer]

Posted in adafruit, game of life, kit review, learning electronicsComments (1)

Getting Started with Arduino! – Chapter Six

This is part of a series titled “Getting Started with Arduino!” – A tutorial on the Arduino microcontrollers. The first chapter is here, and the complete index is here.

Welcome back fellow arduidans!

Hello once again to our regular Arduino tutorial instalment. In this chapter we are up to all sorts of things, including: distance sensing, using prototyping shields, even more shiftiness with shift registers and 4-digit 7-segment displays, and some exercises to refresh and expand your knowledge. Wow – let’s get cracking…

Do you know how to keep your distance? Some people do, some do not. The same goes for mechatronical things (i.e. robots, those little autonomous vacuum cleaners, etc). So to solve that problem you can integrate a distance sensor into your design. Hopefully by following this section you will gain an understanding of such sensors, and be able to make use of them later on in your own projects. Anyhow, today we are looking at the Sharp GP2Y0A21YK0F infra-red distance sensor. What a mouthful… The funny thing is that it looks like a robot head:

sharpsensorsmall

That white JST connector is for three leads, +5V, GND, and analogue out. When purchasing it you should also get a matching lead to save time and mucking about.

How it works is quite simple (I must stop writing that, some things are not as simple as they seem…) – the sensor contains an infra-red transmitter and a receiver. It returns a voltage that is relative to the distance between itself and the object in front of it. This output voltage is inversely proportional to the distance; which is explained better with this graph from the data sheet:

voltagedistance

However it is always fun to test these things out yourself. So I placed a sensor up over my desk, measured out 80cm, and attached the multimeter to the analogue output of the sensor:

sensorchecksmall

A crude setup but effective. I held a white piece of cardboard in front of the sensor, starting from more than one metre away, then moved closer to the minimum, then back out again. As shown in this video clip:

Although watching that multimeter may not have been too interesting, hopefully the next task will be!

Exercise 6.1

Using the values from the graph from the Sharp data sheet (above), make yourself a distance-measuring device. Use an LCD module to display the measurements. Metric and imperial! This shouldn’t be too hard at all, you’re just using one analogue input from the sensor, some basic maths, and displaying some data on an LCD. Furthermore, to make it truly portable, you could wire up a 9v PP3 battery to a DC plug and use it for power. A hint – before calculating distances, run a sketch to just return the analogRead() value from the sensor. Then you can make your own judgement on voltage-distance calculations. To save time I used the Electronic Bricks to rapidly construct this prototype.

You will need:
  • Your standard Arduino setup (computer, cable, Uno or compatible)
  • One parallel LCD display module
  • One Sharp infra-red distance sensor and sensor cable
  • a breadboard and some connecting wire

Anyhow, here is a photo of what I came up with:

exercise6p1small

and the ubiquitous video clip

Finally, my sketch for the solution. You may have to adjust the values in the decision tree for more accuracy. After spending some time with this sensor, I wouldn’t rely on it for exact distance calculations, however it would be very useful for general item detection, air switches and so on. In the next week or two we will examine another type of distance sensor.

What else could this be used for? Robotics sensors, burglar alarms, switching things on and off. Hopefully you have gained some knowledge about this sensor and have some ideas for implementation.

LEDborder

Now that we have spent a few weeks constructing our prototypes on breadboards and electronic bricks, it is now time to look at how we can do this in a more compact, and/or permanent method. As you already know, the Arduino system allows for “shields”, PCBs that plug on top of your Arduino board to add some sort of extra functionality. One of these was the Electronic Brick chassis, another popular shield is the Ethernet shield.

Moving on…

In previous instalments we have worked with 7-segment LED displays, using up to three at once, being controlled by 74HC595 shift registers. As you may have realised by now that involved a lot of wiring, resistors, time and effort. But what if you need four or more digits? Use an LCD… Maybe. Sometimes you need to use LED displays for aesthetic reasons, price, clarity, or just because you love that LED look. Thankfully you can find four digit displays, instead of having to use 2 x 2 or 4 x 1 digit displays. Let’s have a look at one now:

4dig7segsmall

For the newcomer there would be a surprising lack of pins on this display module. That is a good thing, and a slightly tricky thing – but we can overcome the obstacles and use it very easily. How? Again, with two 74HC595 shift registers and some brainpower. Firstly, let’s have a look at the pins – from left to right they are: E, D, C, G, F, B, A, C1, C2, C3, C4, decimal point, unused, unused. This display is common cathode, so to display (for example) the number 1 on digit 3, you would apply ~+2 volts to pins 6 and 7, and attach ground to pin 10. Very much the same as using a single-digit display, except you need to choose the cathode that corresponds with the digit you wish to use. In this tutorial we are using a Common Cathode unit. Out of curiosity’s sake, here is the data sheet for the module used in this chapter: data sheet.pdf.

Secondly, how are we going to control the cathodes with out Arduino? Current comes out of a cathode, so it would not accept a signal from our digital out pins. What we need to do is have a simple switch on each cathode between the display pin and ground, so we can control which digit we want to use. How can we do this with our Arduino? Easy… we can use a simple NPN transistor as a switch. Remember we did this with a relay in chapter three!

But using 4 digital out pins for cathode control is a waste of pins, we can use our trusty shift register again to control the cathodes. So that means we need two shift registers in total, the first to control the digit (0~9), and the second to switch on the cathode of the position we wish to display our digit in. Time to do it!

The first (left-hand) shift register from the Arduino controls the segments on the display, via 560 ohm resistors. Just like last time. The second (right-hand) shift register controls the cathodes. Pins Q0~Q3 connect to the base of a BC548 transistor via a 1k ohm resistor. The collector of the transistor is connected to the cathode on the display, and the emitter to ground. For example:

example6p1schematicsmall

Note that the schematic above is a guide only. But here it is in real life, below:

example6p1small

After a few projects, wiring up displays and shift registers should be a lot quicker for you now. Here is the matching sketch I came up with for the demonstration video below.

You’d have to admit, even in the year 2010, LED displays still look mesmerising. Or maybe that’s just me! Here is the data sheet display.pdf for the LED display I used. You can use other ones,as long as they are common cathode; just match the LED element pins with your first shift register, and the cathode pins with the second shift register.

But on to making something useful…

Exercise 6.2

Using the hardware from example 6.1 above, create a device that displays the value of an analogue sensor. For example, if we connect a 10k variable resistor to an analogue input, the Arduino will return a reading of between 0 and 1023. From a hardware perspective, all you need to do is add an analogue sensor (e.g. LDR, 10k variable resistor, the infra-red sensor from earlier on, etc.). The software will be a little tricky, but if you completed exercise 5.1, or 5.2 you shouldn’t have a problem at all. As you will be displaying one digit at a time, but very quickly, try to minimise the number of times you clear the display – in doing so you will keep the brightness at a maximum.

You will need:

  • Your standard Arduino setup (computer, cable, Uno or compatible)
  • One 4-digit, 7-segment LED display, common cathode
  • Two 74HC595 shift registers
  • Four BC548 or equivalent NPN transistors
  • 8 x 560 ohm 0.25 W resistors. For use as current limiters between the LED display segments and ground
  • One 10k variable resistor
  • a breadboard and some connecting wire

For motivation, here is a video clip of my result. There are two examples, one with leading zeroes, and one without:

And the sketch as well.

That wasn’t too hard was it? Now that you can use such a display, it will become easier to display output from your various projects. Now on to Chapter 6A.

LEDborder

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.

Posted in arduino, distance sensor, education, gp2y0a21yk0f, infrared, IR, lesson, microcontrollers, sharp, tutorialComments (33)

Kit Review – adafruit industries SIM reader (part two)

[Updated 18/03/2013]

Hello readers

Now for the second instalment of my kit review of the adafruit industries SIM card reader. In part one the kit was successfully assembled and the software installed. After some research and some very useful advice from the amazing people at adafruit, we can now move forward to the conclusion of this review.

First of all, a big thanks to adafruit support who pointed me in the direction of something very simple yet crucial: the kit FAQ. Once again I have exhibited the stereotypical behaviour of a male and not read all the instructions first! (Slow clapping from the females in the audience…)  The most crucial point being:

The reader and software looks in the default locations that cell phones use to store SMS and phonebook data – just like the professional forensics software. Some phones do not store any data on SIM cards, instead using their internal memory, and some do a good job of overwriting the data when it is erased. Thus it is not guaranteed that a particular message or phonebook entry will be accessable – it depends a lot on the phone used!

D’Oh.

To cut a long story short another SIM card was acquired that had not been near my handsets, and this worked perfectly. Again, that wonderful feeling of something working filled me with warmth and happiness.

Now for the moment of truth! Insert the SIM card, plug in the cable, connect the PP3 battery if you’re using RS232, and execute:

python pySimReader.py

which after starting up, and you clicking “connect reader” should result with this:

dump2

That’s more like it. Time to examine what the SIM holds… first – the phone book:

dump3

You can double-click on a listing (above left) and the edit entry box appears (above right) allowing you to … edit an entry!

Next we look at the SMS messages function. Unfortunately the SIM card I tested was deactivated and therefore couldn’t be used to receive SMSs. However an excellent demonstration is found in the video at Citizen Engineer (volume one). Finally, we can examine the details of the SIM card itself:

dump4

What are all those acronyms?

  • MSISDN – the phone number attached to that SIM card;
  • Serial number – the SIM serial number, usually printed on the SIM card;
  • IMSI number – a unique number sent by the phone to the network to identify the user;
  • SIM phase – SIM cards were originally ‘Phase 1′, and the phase number increased as the GSM standard was developed over time.

So there you have it. In conclusion, this is an easy to assemble kit which is fun and educational. This is the type of kit that would be good for those who are being introduced to the fascinating world of electronics (etc) as it is quick to build, and does something with the “real world” (i.e. mobile phones) that young people love so much. Or anyone else for that matter. High resolution photos are available on flickr.

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.

[Note - this kit was purchased by myself personally and reviewed without notifying the manufacturer or retailer]

Posted in adafruit, cellphone hacking, kit review, learning electronics, tutorial

Getting Started with Arduino! – Chapter Three

This is chapter three of a series originally titled “Getting Started/Moving Forward with Arduino!” by John Boxall – in what feels like an endless series of articles on the Arduino universe. The first chapter is here, the complete series is detailed here

[Updated 09/01/2013]

In this chapter we will be looking at relays, creating your own functions, interrupts, and servos.

First on the agenda to day are relays.

What is a relay? Think of it as two things that are very close together: a coil that sometimes has a current passing through it; and a switch, that defaults in one direction. When a current passes through the coil, it generates an electromagnetic field which causes the switch to change state. The beauty of a relay is this: you can use a small current and voltage to switch on and off a very large current and/or voltage – and the switch and coil current are isolated from each other. Here is an example of a relay:

relayinternalssmall

If you look closely you can see the coil and the internals of the switch. This particular model has a double-pole, double throw switch. That means two inputs can be switched in either of two directions. The coil needs 12 volts to activate; and the switch can handle 250 volts AC at 5 amps; and the coil resistance is 200 ohms. Ohm’s law (voltage = current x resistance) tells us the coil current is 60mA. No way you can get that sort of current out of an arduino – hence the need for a relay. (Though if anyone wants to try, stand back and film it for us!) The only problem with relays is that they contain moving parts (the switch) and hence will wear out over time. So if you design a relay into a project, be sure to document a maintenance schedule for the end-user or maintenance people.

How will we use this with our arduino? Once again – very easily. But we need a partner in our relay quest – a switching transistor. A simple, garden-variety NPN model will do, such as the BC548. However, when selecting your transistor you need to ensure that it can handle the current of the relay coil. The data sheet for your transistor (e.g. our BC548) will mention a value called Ic – collector current. For our BC548 this is 100mA, and greater than the 60mA of our relay coil. Perfect!

Almost there… when a coil switches off, all the electromagnetic radiation in the coil needs to go somewhere, otherwise it could pulse down into the transistor. Therefore a simple 1A power diode (such as a 1N4004) is placed across the coil, allowing current to flow through the coil and the diode as a loop until it dissipates.

The last thing to verify is the relay coil voltage. If you have a 5V relay, with a low coil current, you can use the arduino power. However in most cases your coil voltage will be 12V, so it will require its own power supply.

Here is the schematic for what you should end up with, using a 12V relay and a low current transistor. Although it isn’t shown in the schematic, connect the GND from the 12V supply to the Arduino GND.  Since writing this article I have found some 5V relays are available, negating the 12v power supply requirement:

examp3p1

So now for a simple test to get a feel for the operation of a relay… here is our sketch:

Our hardware is exactly as the schematic above. Here is a photo:

 
example3_1smallzz
 
And of course a video. Here you can see in detail the coil causing the switch to change poles.
 
 

From here on you understand and can use an arduino to switch a very high current and/or voltage. Please exercise care and consult an expert if you are working with mains voltage. It can KILL you.

Creating your own functions…

There are three main components to an arduino sketch: the variables, the structure and the functions. Functions are the commands that request something to happen, for example analogRead();. You can also define your own functions to improve the structure and flow of your sketch. If you have previous programming experience, you may think of these as sub-procedures, or recall using GOSUB in BASIC all those years ago. An ideal candidate for a custom function would be exercise 2.2 from our last instalment – we could have written functions to organise the min/max display or reset the memory. However, first we must learn to walk before we can run…

Do you remember void loop(); ? I hope so – that is the function that defines your sketch after the setup. What it really does is define the code within into a loop, which runs continuously until you reset the arduino or switch it off. You can simply define your own functions using the same method. For example:

Now that function has been defined, when you want to blink the LED on pin 8 three times, just insert void blinkthree(); into the required point in your sketch. But what if you want to change the number of blinks? You can pass a parameter into your function as well. For example:

So to blink that LED 42 times, execute blinkblink(42); Want to specify your own delay? Try this:

So to blink that LED 42 times, with an on/off period of 367 milliseconds – execute blinkblink(42,367);. It is quite simple, don’t you think? Ok, one more. Functions can also function as mathematical functions. For example:

Do you see what happened there? If our sketch determined the radius of a circle and placed it in a variable radius2, the area of the circle could be calculated by:

Easy.

So now you can create your own functions. Not the most colourful of sections, but it is something we need to know.

Time for a stretch break, go for a walk around for five minutes.

Interrupts…

An interrupt is an event that occurs when the state of a digital input pin changes, and causes a specific function to be called and its contents to be executed.

For example, a robot… while it is happily wandering about a sensor is monitoring a proximity sensor pointing to the ground, which changes state when the robot is lifted off the ground and triggers an interrupt – which could switch off the wheels or sound an alarm (“Help, I’m being stolen!”). I am sure your imagination can think of many other things.

So how do we make an interrupt interrupt? It is relatively easy, with a couple of limitations. You can only monitor two pins (for a normal arduino board) or six with an Arduino mega. Furthermore, you cannot use the function delay() in your interrupt function. Now, you need to decide three things: the pin to monitor (digital 2 or 3, referred to as 0 or 1), the function to run when the interrupt occurs, and what sort of behaviour to monitor on the interrupt pin – that is, the change of state of the pin. Your pins also need to be set to output using pinMode();.

There are four changes of state: LOW (when the pin becomes low), CHANGE (when the pin changes state, from high or from low), RISING (when pin goes from low to high) and FALLING (when pin goes from high to LOW). Initially that looks like  a lot to remember, but it is quite simple when you think about it.

Crikey – that was a lot to take in. So instead of theory, it is time for some practice.

Example 3.2 – interrupt demonstration.

In this example, we will have our random number generator from example 2.2, but with two interrupts being monitored. These will be triggered by push buttons for simplicity: (download)

Of course it wouldn’t be right without a photo of the board layout – we have just reused the LCD set-up from example 2.2, and added two standard push-buttons and 10k resistors (as per page 42 of the book) for the interrupts:

example3_2small

And the video… those switches could really have used a de-bounce circuit, but for the purpose of the demonstration they are not really necessary.

Finally – it’s servo time! I really hope you went through the other sections before heading here – although they may not have been that interesting, they will certainly be useful.

What is a servo?

Think of a little electric motor that is connected to a variable resistor. An electric pulse or command is sent to the motor, and it rotates until it reaches a position that matches a value of the potentiometer. Yes, that sounds a little crazy.

A much simpler explanation is this: a servo is an electric motor that can be commanded to rotate to a specific angular position. For example, they are commonly used to control the steering in a remote-control car. Thankfully once again with arduino and friends, using a servo is very easy, and allows your imagination to go nuts, limited only by the amount of spare time and money you have. :)

When considering the use of a servo, several factors need to be taken into account. These include:

  • rotational range, that is the angular range it can rotate. 180 degrees, 360 degrees (full rotation), etc.
  • the speed at which it can rotate (usually measured in time per degrees)
  • the torque the servo can generate (how strong it is)
  • the amount of current it draws under load
  • weight, cost, and so on

One of the first things that came to mind was “Wow – how many can I use at once?” And the answer is … 12 on the Duemilanove/Uno, and 48 (wow) on the Arduino Mega. Please note you cannot used analogWrite(); on pins 9 and 10 when  using the servo library. For more details, please see the Arduino servo library page. However you will need to externally power the servos (as we did with the 12V relay) for general use. And as always, check the data sheet for your servo before use.

For our examples and exercises today, I am using the Turnigy TG9. It is quite inexpensive and light, good for demonstration purposes and often used in remote control aircraft.  It can rotate within a range of almost 180 degrees (well it was cheap):

servosmall

I hope you noticed that there are three wires to the servo. One is for +5V, one is for GND, and one is the control pin – connect to an Arduino digital out. Which colour is which pin may vary, but for this servo, the darkest is GND, the lightest is control, and the middle colour is the +5V. This servo is very small and doesn’t draw much current, so it’s ok to power from your Arduino board. However, if using something larger, or putting your servo under load – as mentioned earlier you will need to run it from a separate power supply that can deliver the required current. If working with more than a couple of these light-duty servos, you should get an external power supply. Moving forward, when working with angles, you should have a protractor handy. Such as:

protractorsmall

Now how do we control our servo? First of all, we need to use the servo library. In the same manner as we did with the LCD screen in chapter two, place the following line at the start of your sketch:

So now we have access to a range of servo commands.

Then you need to create the servo object in your sketch, so it can be referred to, such as

Then finally, attach the servo to a digital pin for control (within your void(setup); )

That is the setting up out of the way. Now all you need to do is this…

where pos is a value between 0 and 180. (or more or less, depending on the rotational range of your servo).

Now, the proof is in the pudding so to speak, so here once more is an example of it all coming together and rotating. :) The following example moves from left to middle to right and repeats, to give you an idea of what is happening:

The board layout is quite simple, just the three servo wires to the Arduino board:

example3_3small

And the video. The camera does not record audio, so you cannot hear the cute buzz of the servo.

Ok then – that’s enough reading and watching from your end of the Internet. Now it is time for you to make something; using all the knowledge that we have discussed so far…

Exercise 3.1

We can use our digital world to make something useful and different – an analogue digital thermometer, with the following features:

  • analogue temperature display over a 180-degree scale. The range will vary depending on your home climate. My example will be 0~40 degrees Celsius
  • analogue meter showing whether you can have the heater or air-conditioner on, or off. A rendition of exercise 2.1 in analogue form.
  • minimum and maximum temperature display, displayable on demand, with indicators showing what is being displayed (LEDs would be fine); and a reset button

You will need to combine your own functions, working with temperature sensors; a lot of decision-making, digital and analogue inputs, digital and analogue outputs, and some creativity. To reproduce my example of the exercise, you will need the following:

  • Your standard Arduino setup
  • Water (you need to stay hydrated)
  • Analog Devices TMP36 temperature sensor
  • 2 little push buttons
  • 2 x 10k 0.25 W resistors. They work with the buttons to the arduino
  • a breadboard and some connecting wire
  • two LEDs to indicate minimum/maximum
  • 2 x 390 ohm 0.25 W resistors. They are to reduce the current to protect the LEDs.

So off you go… if you have any questions, leave a comment at the end of the post, or email john at tronixstuff dot com.

And now for the results of the exercise. Here are photos of my board layout:

exer3_1boardsmall

exer3_1board2small22

Here you can see the buttons for displaying minimum/maximum temperature, and the reset button. The LEDs indicate the right servo is display minimum or maximum temperature, or illuminate together to ask if you want to reset the memory. And of course, our video:

And here is the sketch for my example board layout. Congratulations to all those who took part and built something useful. Now to move on to Chapter Four.

LEDborder

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.

Posted in arduino, lesson, microcontrollers, relay, servo, tutorialComments (7)

Kit Review – adafruit industries SIM reader (part one)

[Updated 18/03/2013]

In this review will cover the SIM reader from adafruit industries.

The result of this kit is a device that can read the data from a GSM SIM card, such as last-dialled numbers, SMS messages, the phone book, and so on. Although this may not sound like much, the concept of having this sort of technology at home really is amazing; that is – you can learn about the GSM SIM technology and hack into it.

The kit was shipped to me via USPS First Class International postage – taking five days to arrive in Australia from New York. Frankly that’s good enough and therefore no need for a courier.

kitbagsmall

adafruit also set the standard with customs paperwork, with a full and honest declaration inside and out. By doing this I feel it speeds the parcel through Customs… a lot quicker than those packages from Chinese eBay sellers who always put “Gift, US$2″ on everything. Opening up reveals the kit itself, in an anti-static resealable bag. Groovy, packaging I can reuse and not throw away…

kitbagsmall

Another smart move is to not include paper instructions, instead having a very detailed web site and a busy support forum. You can always print the instructions out if you don’t have a PC in your work area. The next thing I love to do is have a look at the components, and get a feel for the kit itself.

partssmall

What stands out with adafruit kits compared to most others (I’m looking at you, Jaycar) is the quality of components. A decent PP3 battery snap that won’t break when you are tired and cranky, branded semiconductors, and a beautiful solder-masked, silk screened PCB. However, no IC socket. Grr. However, one can tell this has been designed by an enthusiast and not some bean-counter.

pcbfrontsmall

 

pcbrearsmall

But that’s enough looking and talking – let’s build it…

My advice at this point is to check you have all the components on hand, and then line them up in order to make it easier while you are soldering. There was also a couple of parts that missed their photo shoot call…

parts2small

If possible, the best way to make adafruit kits is to have your computer in front of you, as you can follow the detailed instructions as you go along. With the instructions up on the screen, the helping hands ready, the fume extractor on, and the tools at my side – it’s time to get cracking.

magnifysmall

First the resistors, protection diode, LED and PP3 snap  …

resistorssmall

Time for a quick test (excellent for confidence-building and troubleshooting) …

testingsmall

Excellent, the LED is working. The rest of the components are easily soldered… as there was no IC socket I soldered opposing pins in order to spread the heat load. The second-last part to fit was the SIM card reader. This had me worried, as if it was damaged, it would take a few days to replace. However, the instructions made it look simple – and it was. Taking a decent photo of it was more difficult…

simreadersmall

And finally, the last part – DB9 fitting for the serial cable to the PC. The kit is supplied with a female connector… but silly me ordered the wrong serial cable, so I am using a male connector. Again, this was easy to fit – the PCB slid between the two rows of pins on the plug, and had large solder pads to make a good strong connection.

db9topsmall

 

db9bottomsmall

OK – we’re done. Now for a SIM card… Ms. Tronixstuff wouldn’t volunteer hers, so mine will be the first victim…

firstvictimsmall

Now time to install the psySIMReader software. It is freely available here with instructions.  Originally my first attempt was with Ubuntu 9.1 and 10.04, but there were too many python errors, and I wasn’t in the mood for learning another language. Eventually I learned how to force the python software to look at COM1 – a good start. But no go – the zero error. Off to a windows xp machine. Seemed ok, but when I attempt to open the COM1 port an error says something about returning zero. This could possibly mean my SIM card is non-standard. *sigh* Went to the supermarket and bought a Vodafone SIM for $2, maybe they are different to my Virgin mobile SIM in some way. On the way back I stopped in again and tried the whole process on the windows xp machine, same error. Vodafone SIM card didn’t work either. Zero for both.

So home again. After reading the support forums, I resoldered all the joints, checked for continuity around the board, reinstalled python and the software, zero error again. Maybe SIM cards have changed a little since the kit was introduced? Then I looked at my serial cable – 3 metres. Perhaps it was too long? So I chopped off one end leaving about 150mm and soldered up another DB9 plug.

newcable-small

Tested the cable, tried again – still the zero error.

Another trawl through the forums and google revealed people having the same zero error, but it being fixed with a resolder job and/or plugging the PCB straight into the serial port on the computer. I cannot do this having originally soldered on a DB9 male to the PCB. Argh. Either it is my soldering or my dodgy serial cable hackup. Soon I will order up an FTDI cable, have someone else check my soldering with better eyes, and then try connecting again.

So at this stage, the verdict is still out. However, I must commend adafruit industries as a great organisation with respect to ordering, speed of delivery, quality and amount of detail on the website, and the support and enthusiasm offered throughout. Their other products have all received rave reviews and are supported much more than adequately.

At this point I will finish part one of the review, and return when the FTDI cable arrives.

[edit] – Click here to visit part two of this review.  High resolution photos are available on flickr.

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.

Posted in adafruit, cellphone hacking, GSM, kit review, learning electronics, SIM reader


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: