digital « t r o n i x s t u f f

Kit Review – JYE Tech FG085 DDS Function Generator

Introduction

There has been a lot of talk lately about inexpensive DDS (direct digital synthesis) function generators, and I always enjoy a kit – so it was time to check out the subject of this review. It’s the “FG085 miniDDS function generator” from JYE Tech. JYE is a small company in China that makes inexpensive test equipment kits, for example their capacitance meter (my first kit review!) and DSO. The capacitance meter was good, the DSO not so good – so let’s hope this is better than their last efforts.

Assembly

The instructions (AssemblyGuide_085G) are much better than previous efforts, and if you have bought the kit – read them. The kit arrives in a large zip-lock bag, with the following bundle of parts:

The AC adaptor is 100~240V in, 15V DC out. Everything is included with the kit including a short BNC to alligator clips lead for output. The PCBs are very good, with a nice solder mask and silk screen:

and back:

At this point we realise that most of the work is already done. There’s two microcontrollers ATmega48 and ATmega168- one for display and user-interface control, and the other for function generation. It takes only a few minutes to solder in the through-hole parts, headers and sockets:

… then you flip over the PCB and add the LCD:

… followed by the buttons and rotary encoder. From previous research this is the part that causes people a lot of trouble – so read carefully. There’s a lot of buttons – and if they aren’t inserted into the PCB correctly your life will become very difficult. The buttons must be inserted a certain way – they’re “polarised” – for example:

As you can see above, one side has a double-vertical line and the other side has a single. When you fit the buttons to the PCB – the side with the double-vertical must face the left-hand side of the PCB – the side with the DC socket. For example:

Furthermore, don’t be in a rush and put all the buttons in then try to solder them all at once. Do them one at a time, and hold them tight to the PCB with some blu-tac or similar. If they don’t sit flush with the PCB the front panel won’t fit properly and the buttons will stick when in use. So exercise some patience, and you’ll be rewarded with an easy to use function generator. Rush them in and you’ll be very unhappy. I warned you! After fitting each button, test fit the front panel to check the alignment, for example:

Then you end up with nicely-aligned buttons:

… which all operate smoothly when the panel is fitted:

After the buttons comes the rotary encoder. Be very careful when fitting it to the PCB – the data legs are really weak, and bend without much effort. If you push in the encoder, be mindful of the legs not going through the holes and bending upwards. Furthermore, when soldering in the encoder note that you’re really close to an electrolytic – you don’t want to stab it with a hot iron:

The CP2012 chip in the image above is for the USB interface. More on that later. Now the next stage is the power-test. Connect DC power and turn it on – you should be greeted by a short copyright message followed by the operation display:

If you didn’t – remove the power and check your soldering – including the capacitor polarities and look for bridges, especially around the USB socket. Now it’s time to fit the output BNC socket. For some reason only known to the designers, they have this poking out the front of the panel for the kit – however previous revisions have used a simple side-entry socket. Thus you need to do some modifications to the supplied socket. First, chop the tag from the sprocket washer:

… then remove the paper from the front panel:

Now solder a link to the washer in a vertical position:

… then fit the BNC socket to the panel, with the washer aligned as such:

Finally, align the top panel with the PCB so the BNC socket pin and washer link drop into the PCB and solder them in:

If you want to use the servo mode, solder three short wires that can attach to a servo form the three “output” pads between the BNC and USB socket.

Finally, screw in the panels and you’re finished!

Using the function generator

Operation is quite simple, and your first reference should be the manual (manual.pdf). The display defaults to normal function generator mode at power-up – where you can adjust the frequency, offset, amplitude and type of output – sine, square, triangle, ramp up, ramp down, staircase up and down:

The ranges for all functions is 0~10 khz, except for sine which can hit 200 kHz. You can enter higher frequencies, such as up to 250 kHz for sine – but the results aren’t so good.

Instead of filling this review with lots of screen dumps from an oscilloscope to demonstrate the output – I’ve made the following video where you can see various functions being displayed on a DSO:

You can also create signals to test servos, with adjustable pulse-width, amplitude and cycle times. However you’ll need to solder three wires onto the PCB (next to the BNC socket area) to attach to the servo.

According to the user manual and various retailers’ websites – the FG085 can generate frequency sweeping signals. These are signals that sweep from a start to as finish frequency over a period of time. However the firmware on the supplied unit is old and needs updating to enable this function. You can download the firmware in .hex file format from here. Then go and dig up an AVR programmer and avrdude. At the time of writing we had some issues with the signature not being recognised when updating the firmware, and solidly bricked the FG085. Our fault – so when that’s sorted out we’ll update the review – stay tuned.

There is also a USB port on the side – after installing CP2102 drivers in Windows we could connect at 115200 bps with terminal, however all the FG085 returned was the firmware version number. Perhaps later on the designers will update the firmware to allow for PC control. Somehow I wouldn’t bank on it.

Oh – if you’re wondering what DDS is - click here!

Conclusion

It’s an interesting piece of equipment. Putting the firmware upgrade issues to one side, the FG085 does what it sets out to do. During testing it worked well, and we didn’t come across any obvious inaccuracies during use. The price varies between US$43 and $50 – so for that money it’s a good kit. Just take care during construction and you’ll be fine.

The function generator is available in kit form or assembled, with or without panels from China. The kit version with panels is also available from Sparkfun (KIT-11394) and their resellers. Full-sized images available on flickr. This kit was purchased and reviewed without notifying the supplier.

In the meanwhile have fun and keep checking into tronixstuff.com. Why not follow things on twitter, Google+, 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.

February 6, 2013 Posted by John Boxall | dds, ds2102, function generator, kit review, KIT-11394, learning electronics, rigol, test equipment | dds, digital, direct, ds2102, fg085, frequency, generator, jyetech, kit, KIT-11394, review, rigol, servo, sine, square, staircase, sweep, synthesis, triangle, tronixstuff, wave | 2 Comments

Project: Clock Two – Single digit clock

Let’s hack an Ikea lamp into a single-digit clock! How? Read on…

Updated 18/03/2013

Time for another instalment in my irregular series of clock projects. (Or should that be “Time for another instalment in the series of irregular clock projects”?) In contrast with the extreme “blinkiness” of Clock One, in this article we describe how to build this single-digit digital clock:

hello!

Once again the electronics of the clock will be based from an Arduino-compatible board with a DS1307 real-time clock IC added to the board. On top of this we add a shield with some extra circuitry and two buttons – but more on this later. The inspiration for this clock came from a product that was recently acquired at Ikea – the “Kvart” work lamp, for example:

from http://www.ikea.com.au

If you are shopping for one, here are the Ikea stock details:

The goal is to place the electronics of the clock in the base, and have one single-digit LED display at the top of the neck which will blink out the digits. There will be two buttons under the base that are used to set the time. It will be powered by a 9V battery or an AC adaptor which is suitable for a typical Arduino board.

Construction

This article is a diary of my construction, and you can always use your own knowledge and initiative. It is assumed that you have a solid knowledge of the basics of the Arduino system. If not, review my series of tutorials available from here. Furthermore, feel free to modify the design to work with what you have available – I hope this article can be of some inspiration to you.

Software

It is much easier to prototype the clock and get the Arduino sketch working how you like it before breaking down the lamp and building up the clock. To do this involves some jumper wires and a solderless breadboard, for example:

Although there are four buttons on the board we only use two. They are connected to digital pins eight and nine (with 10k pull-down resistors). The LED display segments a~g are connected to Arduino digital pins 0~6 respectively. The decimal point is connected to the pulse output pin of the DS1307 – which will be set to a 1Hz output to have a nice constant blinking to show the clock is alive and well.

If you are unfamiliar with operating the DS1307 real-time clock IC please review this tutorial. Operation of the clock has been made as simple for the user as possible. To set the time, they press button A (on digital eight) while the current time is being displayed, after which point the user can select the first digit (0~2) of the time by pressing button A. Then they press button B (on digital nine) to lock it in and move to the second digit (0~9) which is again chosen with button A and selected with button B. Then they move onto the digits in the same manner.

After this process the new time is checked for validity (so the user cannot enter invalid times such as 2534h) – and is ok, the clock will blink the hyphen twice and then carry on with the new time. If the entered time is invalid, the clock reverts back to the current time. This process is demonstrated in the following video clip:

You can download the Arduino sketch from here.

Hardware

The parts required to replicate the Clock Two in this article are:

One Arduino-compatible board with DS1307 real-time clock IC as described in this article
One Arduino protoshield and header pins
One common-cathode 7-segment LED display of your choosing
Seven current-limiting resistors to reduce the output current from Arduino digital outputs going to the LED segments. In our example we use a 560 ohm resistor network to save time
Two buttons and two 10k ohm pull-down resistors
One meter of nine-core wire that will fit inside the neck and stand of the Kvart lamp – an external diameter of less than 6mm will be fine
And of course – the lamp

The protoshield is used to hold the buttons, resistor network and the terminus for the wires between the LED display and the Arduino digital outputs, for example:

At this stage you will need to do some heavy deconstruction on the lamp. Cut off the mains lead at the base and remove the plastic grommet from the stand that surrounded the AC lead. Next, with some elbow grease you can twist off the lamp-shade unit from the end of the flexible neck. You could always reuse the lamp head and AC lead if wired by a licensed electrician.

Now you need to feed the multicore wire through the neck and down to the base of the lamp. You can pull it through the hole near the base, and then will need to drill a hole in the base to feed it through to the electronics as such:

Take care when feeding the cable though so you don’t nick the insulation as shown above. Leave yourself a fair bit of slack at the top which will make life easier when soldering on the LED display, for example:

The next step is to solder the wires at the top to the LED display. Make notes to help recall which wires are soldered to the pins of the display. If your soldering skills (like mine) aren’t so good, use heatshrink to cover the soldering:

Most displays will have two GND pins, so bridge them so you only need to use one wire in the multicore back to base:

At this point use the continuity function of a multimeter or a low-voltage power source to test each LED segment using the other end of the cable protruding from the base. Once you are satisfied the segments have been soldered correctly, carefully draw the cable back through the neck and base in order to reduce the slack between the display and the top of the lamp neck. Then solder the individual LED segment wires to the protoshield.

Now if you have not already done so, upload the sketch into the Arduino board – especially if you are going to permanently mount the circuitry into the base. A simple method of mounting would be using a hot glue gun, but for the purpose of demonstration we have just used blu-tac:

Although this does look a little rough, we are using existing stock which kept the cost down. If you are going to power the clock with an AC adaptor, you will also need to cut out small opening to allow the lead to protrude from the side of the base. And now for the resulting clock – our Clock Two:

So there you have it, the second of many clocks we plan to describe in the future.

February 21, 2012 Posted by John Boxall | arduino, clocks, ds1307, DS3232, hardware hacking, Ikea, kvart, tutorial, Uncategorized | arduino, clock, digit, digital, DS1307, ds3232, hack, hacking, i2c, ikea, kvart, lamp, lesson, lessons, project, RTC, single, tronixstuff, tutorial, tutorials, two | 13 Comments

Using an ATtiny as an Arduino

Learn how to use ATtiny45 and ATtiny85 microcontrollers with Arduino in chapter forty-four of a series originally titled “Getting Started/Moving Forward with Arduino!” by John Boxall – a series of articles on the Arduino universe. The first chapter is here, the complete series is detailed here.

Updated 07/02/2013

Did you know you can use an Atmel ATtiny45 or ATtiny85 microcontroller with Arduino software? Well you do now. The team at the High-Low Tech Group at MIT have published the information and examples on how to do this, and it looked like fun – so the purpose of this article is to document my experience with the ATtiny and Arduino and share the instructions with you in my own words. All credit goes to the interesting people at the MIT HLT Group for their article and of course to Alessandro Saporetti for his work on making all this possible.

Introduction

Before anyone gets too excited – there are a few limitations to doing this…

Limitation one – the ATtiny has “tiny” in the name for a reason:

it’s the one on the left

Therefore we have less I/O pins to play with. Consider the pinout for the ATtiny from the data sheet:

So as you can see we have thee analogue inputs (pins 7, 3 and 2) and two digital outputs with PWM (pins 5 and 6). Pin 4 is GND, and pin 8 is 5V.

Limitation two – memory. The ATtiny45 has 4096 bytes of flash memory available, the -85 has 8192. So you may not be controlling your home-built R2D2 with it.

Limitation three – available Arduino functions. As stated by the HLT article, the following commands are supported:

Other functions may work or become available over time.

Limitation four - You need Arduino IDE v1.0.1 or higher, except for v1.0.2. So v1.0.3 and higher is fine.

So please keep these limitations in mind when planning your ATtiny project.

Getting Started

There are two ways you can program your ATtiny. Method one describes using an Arduino board, method two describes using a separate USB programmer.

Programmer method one

You can use an existing Arduino-compatible board as a programmer with some external wiring. Before wiring it all up – plug in your Arduino board, load the IDE and upload the ArduinoISP sketch which is in the File>Examples menu. Whenever you want to upload a sketch to your ATtiny, you need to upload the ArduinoISP sketch to your Arduino first. Consider this sketch the “bridge” between the IDE and the ATtiny.

Next, build the circuit as shown below (click image to enlarge):

Depending on the Arduino board you’re using, you may or may not need the 10uF capacitor between Arduino RST and GND. Follow the schematic above each time you want to program the ATtiny.

Software

From a software perspective, to use the ATtinys you need to add some files to your Arduino IDE. First, download this zip file. Then extract the”attiny” folder and copy it to the “hardware” folder which sits under your main Arduino IDE folder, for example (click image to enlarge):

Now restart the Arduino IDE. As you’re using the Arduino as a programmer, you need select “Arduino as ISP” – which is found in the Tools>Programmer menu. Next – select the board type using the Tools>Board menu. Select the appropriate ATtiny that you’re using – with the 1 MHz internal clock option. Now you can enter and upload your ATtiny sketch. When uploading sketches you may see error messages as shown below:

The message is “normal” in this situation, so nothing to worry about. Now – scroll down until you reach the “Creating Arduino sketches for ATtinys” section to continue with the tutorial.

Programmer method two

Get yourself one of these USB programming boards:

They’re great – you just drop in the ATtiny – plus you can use it as a breakout board. And there’s an LED on pin 5 for testing with blink and debugging in general.

Insert your ATtiny into the board, plug it into a free USB port and the hardware is done. If you’re using Windows – install the necessary drivers (32-bit or 64-bit). Next, restart the Arduino IDE and select “USBtinyISP” – which is found in the Tools>Programmer menu. Next – select the board type using the Tools>Board menu. Select the appropriate ATtiny that you’re using – with the 1 MHz internal clock option. Now you can enter and upload your ATtiny sketch. Note that you don’t need to select a USB port in the IDE, and the option may well be blanked out – instead, check the bottom-right of the IDE. It will show the USB port being used by the programmer board, for example:

Creating Arduino sketches for ATtinys

When creating your sketches, note that the pin number allocations are different for ATtinys in the IDE. Note the following pin number allocations:

digital pin zero is physical pin five (also PWM)
digital pin one is physical pin six (also PWM)
analogue input two is physical pin seven
analogue input three is physical pin two
analogue input four is physical pin three

For a quick demonstration, load the Blink example sketch – File>Examples>1. Basics>Blink. Change the pin number for the digital output from 13 to 0. For example:

void setup()
{
 pinMode(0, OUTPUT);
}

void loop() {
 digitalWrite(0, HIGH); // set the LED on
 delay(1000); // wait for a second
 digitalWrite(0, LOW); // set the LED off
 delay(1000); // wait for a second
}

Upload the sketch using the methods described earlier. If you’re using programmer method one, your matching circuit is:

If you’re using programmer method two, this will blink the on-board LED.

Final example

We test the digital outputs with digital and PWM outputs using two LEDs instead of one:

And the sketch:

void setup()
{
   pinMode(0, OUTPUT);
   pinMode(1, OUTPUT);
}
void loop()
{
   for (int a=0; a<6; a++)
   {
     digitalWrite(0, HIGH); // set the LED on
     digitalWrite(1, LOW); // set the LED off
     delay(1000); // wait for a second
     digitalWrite(0, LOW); // set the LED off
     digitalWrite(1, HIGH); // set the LED on
     delay(1000); // wait for a second
   }
for (int z=0; z<3; z++)
 {
   for (int a=0; a<256; a++)
   {
     analogWrite(0, a);
     analogWrite(1, a);
     delay(1);
   }
   for (int a=255; a>=0; --a)
   {
     analogWrite(0, a);
     analogWrite(1, a);
     delay(1);
   }
 }
}

And a quick demonstration video:

So there you have it – another interesting derivative of the Arduino system. Once again, thanks and credit to Alesssandro Saporetti and the MIT HLT Group for their published information.

Have fun and keep checking into tronixstuff.com. Why not follow things on twitter, Google+, 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.

November 23, 2011 Posted by John Boxall | arduino, attiny, attiny45, attiny85, COM-09378, microcontrollers, PGM-11460, tutorial | analog, arduino, attiny, attiny45, attiny85, bootloader, COM-09378, digital, hlt, lesson, lessons, miniature, mit, PGM-11460, programming, PWM, tronixstuff, tutorial, tutorials | 6 Comments

Review – Tenma 72-7222 Digital Clamp Multimeter

Hello readers

The purpose of this article is to examine the Tenma 72-7222 Digital Clamp Multimeter supplied for review by element-14/Farnell/Newark. The Tenma is a strongly featured yet inexpensive piece of test equipment – and considerably good value when you consider there is a current clamp for measuring high AC currents. So let’s have a look and see what we have.

Initial Impression

The Tenma arrives in a retail box, and generally nicely packaged. Naturally this has nothing to do with the performance of the meter at all, but at least they made an effort:

Opening up we find a nicely rounded group of items: the meter itself, some no-name AAA cells, test leads, a thermocouple for temperature measurement, a surprisingly articulate and well-written user manual, and the unit itself – all within a nice pouch. Wow – a pouch. Agilent? Fluke? All that money for a DMM and you don’t include a pouch?

Recent test equipment reviewers have made pulling apart the unit part of the review – so here goes… the back comes off easily:

No user-replaceable fuses… instead a PTC. A closer look at the PCB:

A very neat and organised PCB layout. There are plastic tabs that hold the PCB in along with a screw, however the case flexed too much for me to warrant removing the PCB completely. The spring for the clamp meter is locked in nicely and very strong, it won’t give up for a long time. Pulling the clamp base out reveals the rest of the PCB:

Installation of the battery is two stage procedure, first you need to remove a screw and then slide out the rear door:

… then insert the AAA cells into a frame, which is then inserted inside the unit:

The physical feel of the unit is relative to the purchase price, the plastic is simple and could be quite brittle if the unit was dropped from a height. The user manual claims the unit can be dropped from up to a height of one metre. Onto carpet? Yes. Concrete? Perhaps not. However like all test equipment one would hope the user would take care of it whenever possible. The clamp meter is very strong due to the large spring inside the handle, which can be opened up to around 28mm. The included leads are just on one meter long including the length of the probe:

The leads are rated to Category I 1000V (overkill – the meter can’t go that high) and 600 V Category II – “This category refers to local-level electrical distribution, such as that provided by a standard wall outlet or plug in loads (for example, 115 AC voltage for U.S. or 200 AC voltage for Europe). Examples of Measurement Category II are measurements performed on household appliances, portable tools, and similar modules” – definition from from National Instruments. Unlike discount DMMs from unknown suppliers you can trust the rating to be true – otherwise element-14 wouldn’t be selling it.

Unit Specifications

Voltage Measuring Range DC:200mV, 2V, 20V, 200V, 600V
Voltage Measuring Range AC:2V, 20V, 200V, 600V
Current Measuring Range AC:2A, 20A, 200A, 400A
Resistance Measuring Range:200ohm, 2kohm, 20kohm, 200kohm, 2Mohm, 20Mohm
Temperature Measuring Range:-40°C to +1000°C
DMM Response Type:True RMS
DMM Functions:AC Current, AC/DC Voltage, Resistance, Temperature
Ranging:Auto
Display Count:1999
AC Current Range Accuracy:± (1.5% + 5d)
AC Voltage Range Accuracy:± (1.2% + 5d)
Accuracy:± (1.0% + 3d)
Current AC Max:400A
Current Range AC:2A, 20A, 200A, 400A
DC Voltage Range Accuracy1:± (0.8% + 1d)
Resistance Range Accuracy:± (1.0% + 2d)
Temperature Measuring Range:-40°C to +1000°C

The only measurement missed out on is DC current, however there is the Tenma 72-7224 which has DC current and frequency ranges. Finally, all the modes and buttons can be selected while holding the meter with one hand – for both left- and right-handed folk.

Measurement experience

Normally I would compare the measurements against my Agilent U1272A, however it’s out to lunch. Instead, a Fluke 233. First, AC voltage from the mains:

Next, a few DC voltage measurements:

Now for some resistance measurements. Higher values near the maximum of 20M Ohm can take around four seconds to measure:

Forward voltage of a 1N4004 diode:

Now off to the kitchen for some more measurements – first with the thermocouple:

The boiling water test – 100 degrees Celsius (you can also select Fahrenheit if so inclined):

And now to test out the AC current clamp meter function with a 10A kettle at boiling point. First, using the 20A current range:

And then again on the 400A current range:

As always, it’s best to use the multimeter range that more closely corresponds with the current under test. The meter also has a continuity test with a beeper, however it was somewhat slow and would often take around one second to register – so nothing too impressive on that front. The meter can record the maximum value with the grey button, or hold a reading using the yellow button.

Conclusion

The Tenma 72-7222 works as advertised, and as expected. It is a solid little unit that if looked after should last a few years at a minimum. It certainly has a few limitations, such as the 1999 count display, lack of backlight, and the average continuity function. But don’t let that put you off. For the price – under Au$30 – it is a certified deal. If you need a clamp current meter for odd jobs or a casual-use multimeter and you are on a limited budget, the Tenma will certainly prove a worthwhile purchase. Full-size images are available on Flickr.

You can purchase a Tenma 72-7222 from element-14, Farnell and Newark.

Thanks for reading! Have fun and keep checking into tronixstuff.com. Why not follow things on twitter, Google+, 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.

[Note - The Tenma 72-7222 Digital Clamp Multimeter was a promotional consideration from element-14/Farnell/Newark]

October 11, 2011 Posted by John Boxall | review, test equipment | 72-7222, 727222, AC, clamp, clampmeter, current, digital, dmm, element-14, high, measurement, meter, multimeter, newark, review, tenma, tronixstuff | 2 Comments

Tutorial: Arduino timing methods with millis()

This is chapter thirty-seven 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. Any files from tutorials will be found here.

[Updated 20/01/2013]

In this article we introduce the millis(); function and put it to use to create various timing examples.

Millis? Nothing to do with lip-syncers… hopefully you recognised milli as being the numerical prefix for one-thousandths; that is multiplying a unit of measure by 0.001 (or ten to the power of negative 3). Interestingly our Arduino systems will count the number of milliseconds (thousands of a second) from the start of a sketch running until the count reaches the maximum number capable of being stored in the variable type unsigned long (a 32-bit [four byte] integer – that ranges from zero to (2^32)-1.

(2^32)-1, or 4294967295 milliseconds converts to 49.71027-odd days. The counter resets when the Arduino is reset, it reaches the maximum value or a new sketch is uploaded. To get the value of the counter at a particular juncture, just call the function – for example:

start=millis();

Where start is an unsigned long variable. Here is a very simple example (download sketch) to show you millis() in action:

Example 37.1

/*
  Example 37.1 - millis() demonstration
  http://tronixstuff.wordpress.com/tutorials > chapter 37
  John Boxall | CC by-sa-nc
*/

unsigned long start, finished, elapsed;

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  Serial.println("Start...");
  start=millis();
  delay(1000);
  finished=millis();
  Serial.println("Finished");
  elapsed=finished-start;
  Serial.print(elapsed);
  Serial.println(" milliseconds elapsed");
  Serial.println();
  delay(500);
}

The sketch stores the current millis count in start, then waits one second, then stores the value of millis again in finished. Finally it calculates the elapsed time of the delay. In the following screen dump of the serial monitor, you can see that the duration was not always exactly 1000 milliseconds:

To put it simply, the millis function makes use of an internal counter within the ATmega microcontroller at the heart of your Arduino. This counter increments every clock cycle – which happens (in standard Arduino and compatibles) at a clock speed of 16 Mhz. This speed is controlled by the crystal on the Arduino board (the silver thing with T16.000 stamped on it):

Crystal accuracy can vary depending on external temperature, and the tolerance of the crystal itself. This in turn will affect the accuracy of your millis result. Anecdotal experience has reported the drift in timing accuracy can be around three or four seconds per twenty-four hour period. If you are using a board or your own version that is using a ceramic resonator instead of a crystal, note that they are not as accurate and will introduce the possibility of higher drift levels. If you need a much higher level of timing accuracy, consider specific timer ICs such as the Maxim DS3232.

Now we can make use of the millis for various timing functions. As demonstrated in the previous example sketch, we can calculate elapsed time. To take this idea forward, let’s make a simple stopwatch. Doing so can be as simple or as complex as necessary, but for this case we will veer towards simple. On the hardware perspective, we will have two buttons – Start and Stop - with the 10k ohm pull-down resistors connected to digital pins 2 and 3 respectively.

When the user presses start the sketch will note the value for millis – then after stop is pressed, the sketch will again note the value for millis, calculate and display the elapsed time. The user can then press start to repeat the process, or stop for updated data. Here is the sketch (download):

Example 37.2

/*
  Example 37.2 – Super-basic stopwatch using millis();
  http://tronixstuff.wordpress.com/tutorials > chapter 37
  John Boxall | CC by-sa-nc
*/

unsigned long start, finished, elapsed;

void setup()
{
  Serial.begin(9600);
  pinMode(2, INPUT); // start button
  pinMode(3, INPUT); // stop button
  Serial.println("Press 1 for Start/reset, 2 for elapsed time");
}

void displayResult()
{
  float h,m,s,ms;
  unsigned long over;
  elapsed=finished-start;
  h=int(elapsed/3600000);
  over=elapsed%3600000;
  m=int(over/60000);
  over=over%60000;
  s=int(over/1000);
  ms=over%1000;
  Serial.print("Raw elapsed time: ");
  Serial.println(elapsed);
  Serial.print("Elapsed time: ");
  Serial.print(h,0);
  Serial.print("h ");
  Serial.print(m,0);
  Serial.print("m ");
  Serial.print(s,0);
  Serial.print("s ");
  Serial.print(ms,0);
  Serial.println("ms");
  Serial.println();
}

void loop()
{
  if (digitalRead(2)==HIGH)
  {
    start=millis();
    delay(200); // for debounce
    Serial.println("Started...");
  }
  if (digitalRead(3)==HIGH)
  {
    finished=millis();
    delay(200); // for debounce
    displayResult();
  }
}

The calls to delay() are used to debounce the switches – these are optional and their use will depend on your hardware. Below is an example of the sketch’s serial monitor output – the stopwatch has started, and then button two pressed six times across periods of time:

If you had a sensor at the start and end of a fixed distance, speed could be calculated: speed = distance ÷ time.

You can also make a speedometer for a wheeled form of motion, for example a bicycle. At the present time I do not have a bicycle to mess about with, however we can describe the process to do so – it is quite simple. (Disclaimer – do so at your own risk etc.) First of all, let’s review the necessary maths. You will need to know the circumference of the wheel. Hardware – you will need a sensor. For example – a reed switch and magnet. Consider the reed switch to be a normally-open button, and connect as usual with a 10k ohm pull-down resistor. Others may use a hall-effect sensor – each to their own). Remember from maths class:

(image licence)

To calculate the circumference – use the formula:

circumference = 2πr

where r is the radius of the circle. Now that you have the wheel circumference, this value can be considered as our ‘fixed distance’, and therefore the speed can be calculated by measuring the elapsed time between of a full rotation.

Your sensor – once fitted – should act in the same method as a normally-open button that is pushed every rotation. Our sketch will measure the time elapsed between every pulse from the sensor. To do this, our example will have the sensor output connected to digital pin 2 – as it will trigger an interrupt to calculate the speed. (Interrupts? See chapter three). The sketch will otherwise be displaying the speed on a normal I2C-interface LCD module. The I2C interface is suggested as this requires only 4 wires from the Arduino board to the LCD – the less wires the better.

Here is the sketch for your perusal (download):

Example 37.3

/*
  Example 37.3 – Basic speedometer using millis();
  http://tronixstuff.wordpress.com/tutorials > chapter 37
  John Boxall | CC by-sa-nc
*/

#include "Wire.h" // for I2C bus LCD
#include "LiquidCrystal_I2C.h" // for I2C bus LCD module - http://bit.ly/m7K5wt
LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display

float start, finished;
float elapsed, time;
float circMetric=1.2; // wheel circumference relative to sensor position (in meters)
float circImperial; // using 1 kilometer = 0.621371192 miles
float speedk, speedm;    // holds calculated speed vales in metric and imperial

void setup()
{
  attachInterrupt(0, speedCalc, RISING); // interrupt called when sensors sends digital 2 high (every wheel rotation)
  start=millis();
  // setup LCD
  lcd.init();      // initialize the lcd
  lcd.backlight(); // turn on LCD backlight
  lcd.clear();
  lcd.println(" Wear a helmet! ");
  delay(3000);
  lcd.clear();
  Serial.begin(115200);
  circImperial=circMetric*.62137; // convert metric to imperial for MPH calculations
}

void speedCalc()
{
  elapsed=millis()-start;
  start=millis();
  speedk=(3600*circMetric)/elapsed; // km/h
  speedm=(3600*circImperial)/elapsed; // Miles per hour
}

void loop()
{
  lcd.setCursor(0,0);
  lcd.print(int(speedk));
  lcd.print(" km/h ");
  lcd.print(int(speedm));
  lcd.print(" MPH   ");
  lcd.setCursor(0,1);
  lcd.print(int(elapsed));
  lcd.print(" ms/rev      ");
  delay(1000); // adjust for personal preference to minimise flicker
}

There isn’t that much going on – every time the wheel completes one revolution the signal from the sensor will go from low to high – triggering an interrupt which calls the function speedCalc(). This takes a reading of millis() and then calculates the difference between the current reading and the previous reading – this value becomes the time to cover the distance (which is the circumference of the wheel relative to the sensor – stored in

float circMetric=1.2;

and is measured in metres). It finally calculates the speed in km/h and MPH. Between interrupts the sketch displays the updated speed data on the LCD as well as the raw time value for each revolution for curiosity’s sake. In real life I don’t think anyone would mount an LCD on a bicycle, perhaps an LED display would be more relevant.

In the meanwhile, you can see how this example works in the following short video clip. Instead of a bike wheel and reed switch/magnet combination, I have connected the square-wave output from a function generator to the interrupt pin to simulate the pulses from the sensor, so you can get an idea of how it works:

That just about sums up the use of millis() for the time being. There is also the micros(); function which counts microseconds.

So there you have it – another practical function that can allow more problems to be solved via the world of Arduino. As always, now it is up to you and your imagination to find something to control or get up to other shenanigans.

June 22, 2011 Posted by John Boxall | arduino, education, learning electronics, microcontrollers, timing | applications, arduino, clock, digital, DIY, duemilanove, eleven, freetronics, how, km/h, learn, lesson, lessons, micros(), microseconds, millis();, milliseconds, MPH, ms, real, RTC, speedo, speedometer, stopwatch, time, timing, to, tronixstuff, tutorial, tutorials, understand, uno, uS | 16 Comments

Tutorial: Arduino and the SPI bus part II

This is chapter thirty-six of a series originally titled “Getting Started/Moving Forward with Arduino!” by John Boxall – A seemingly endless series of articles on the Arduino universe. The first chapter is here, the complete series is detailed here.

[Updated 10/01/2013]

This is the second of several chapters in which we are investigating the SPI data bus, and how we can control devices using it with our Arduino systems. If you have not done so already, please read part one of the SPI articles. Again we will learn the necessary theory, and then apply it by controlling a variety of devices. As always things will be kept as simple as possible.

First on our list today is the use of multiple SPI devices on the single bus. We briefly touched on this in part one, by showing how multiple devices are wired, for example:

Notice how the slave devices share the clock, MOSI and MISO lines – however they both have their own chip select line back to the master device. At this point a limitation of the SPI bus becomes prevalent – for each slave device we need another digital pin to control chip select for that device. If you were looking to control many devices, it would be better to consider finding I2C solutions to the problem. To implement multiple devices is very easy. Consider the example 34.1 from part one – we controlled a digital rheostat. Now we will repeat the example, but instead control four instead of one. For reference, here is the pinout diagram:

Doing so may sound complex, but it is not. We connect the SCK, MOSI and MISO pins together, then to Arduino pins D13, D11, D12 respectively. Each CS pin is wired to a separate Arduino digital pin. In our example rheostats 1 to 4 connect to D10 through to D7 respectively. To show the resistance is changing on each rheostat, there is an LED between pin 5 and GND and a 470 ohm resistor between 5V and pin 6. Next, here is the sketch (download):

Example 36.1

/*
 Example 36.1 - Multiple SPI bus device demo using four Microchip MCP4162s [http://bit.ly/iwDmnd]
 http://tronixstuff.com/tutorials > chapter 36 | CC by-sa-nc | John Boxall
*/

#include "SPI.h" // necessary library
int del=3; // used for various delays

int led1=10; // CS lines for each SPI device
int led2=9;
int led3=8;
int led4=7;

void setup()
{
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
  digitalWrite(led1, HIGH);
  digitalWrite(led2, HIGH);
  digitalWrite(led3, HIGH);
  digitalWrite(led4, HIGH);
  SPI.begin(); // wake up the SPI bus.
  SPI.setBitOrder(MSBFIRST);
  // our MCP4162s requires data to be sent MSB (most significant byte) first
}

void setValue(int l, int value)
// sends value 'value' to SPI device on CS digital out pin 'l'
{
  digitalWrite(l, LOW);
  SPI.transfer(0); // send command byte
  SPI.transfer(value); // send value (0~255)
  digitalWrite(l, HIGH);
}

void allOff()
// sets all pots to max resistance
{
     setValue(led1,255);
     setValue(led2,255);
     setValue(led3,255);
     setValue(led4,255);
}

void pulse(int l)
{
  allOff();
  for (int a=255; a>=0; --a)
  {
    setValue(l,a);
    delay(del);
  }
  for (int a=0; a<256; a++)
  {
    setValue(l,a);
    delay(del);
  }
}

void pulseAll()
{
  allOff();
  for (int a=255; a>=0; --a)
  {
    setValue(led1,a);
    setValue(led2,a);
    setValue(led3,a);
    setValue(led4,a);
    delay(del);
  }
  for (int a=0; a<256; a++)
  {
    setValue(led1,a);
    setValue(led2,a);
    setValue(led3,a);
    setValue(led4,a);
    delay(del);
  }
}

void loop()
{
  pulse(led1);
  pulse(led2);
  pulse(led3);
  pulse(led4);
  pulseAll();
}

Although the example sketch may be longer than necessary, it is quite simple. We have four SPI devices each controlling one LED, so to keep things easy to track we have defined led1~led4 to match the chip select digital out pins used for each SPI device. Then see the first four lines in void setup(); these pins are set to output in order to function as required. Next – this is very important – we set the pins’ state to HIGH. You must do this to every chip select line! Otherwise more than one CS pins may be initially low in some instances and cause the first data sent from MOSI to travel along to two or more SPI devices. With LEDs this may not be an issue, but for motor controllers … well it could be.

The other point of interest is the function

void setValue(int l, int value)

We pass the value for the SPI device we want to control, and the value to send to the device. The value for l is the chip select value for the SPI device to control, and ranges from 10~7 – or as defined earlier, led1~4. The rest of the sketch is involved in controlling the LED’s brightness by varying the resistance of the rheostats. Now to see example 36.1 in action via the following video clip:

(If you are wondering what I have done to the Freetronics board in that video, it was to add a DS1307 real-time clock IC in the prototyping section).

Next on the agenda is a digital-to-analogue converter, to be referred to using the acronym DAC. What is a DAC? In simple terms, it accepts a numerical value between zero and a maximum value (digital) and outputs a voltage between the range of zero and a maximum relative to the input value (analogue). One could consider this to be the opposite of the what we use the function analogRead(); for. For our example we will use a Microchip MCP4921 (data sheet.pdf):

(Please note that this is a beginners’ tutorial and is somewhat simplified). This DAC has a 12-bit resolution. This means that it can accept a decimal number between 0 and 4095 – in binary this is 0 to 1111 1111 1111 (see why it is called 12-bit) – and the outpout voltage is divided into 4096 steps. The output voltage for this particular DAC can fall between 0 and just under the supply voltage (5V). So for each increase of 1 in the decimal input value, the DAC will output around 1.221 millivolts.

It is also possible to reduce the size of the voltage output steps by using a lower reference voltage. Then the DAC will consider the reference voltage to be the maximum output with a value of 4095. So (for example) if the reference voltage was 2.5V, each increase of 1 in the decimal input value, the DAC will output around 0.6105 millivolts. The minimum reference voltage possible is 0.8V, which offers a step of 200 microvolts (uV).

The output of a DAC can be used for many things, such as a function generator or the playback of audio recorded in a digital form. For now we will examine how to use the hardware, and monitoring output on an oscilloscope. First we need the pinouts:

By now these sorts of diagrams shouldn’t present any problems. In this example, we keep pin 5 permanently set to GND; pin 6 is where you feed in the reference voltage – we will set this to +5V; AVss is GND; and Vouta is the output signal pin – where the magic comes from The next thing to investigate is the MCP4921′s write command register:

Bits 0 to 11 are the 12 bits of the output value; bit 15 is an output selector (unused on the MPC4921); bit 14 controls the input buffer; bit 13 controls an inbuilt output amplifier; and bit 12 can shutdown the DAC. Unlike previous devices, the input data is spread across two bytes (or a word of data). Therefore a small amount of work needs to be done to format the data ready for the DAC. Let’s explain this through looking at the sketch for example 36.2 that follows. The purpose of the sketch is to go through all possible DAC values, from 0 to 4095, then back to 0 and so on.

First. note the variable outputvalue - it is a word, a 16-bit unsigned variable. This is perfect as we will be sending a word of data to the DAC. We put the increasing/decreasing value for a into outputValue. However as we can only send bytes of data at a time down the SPI bus, we will use the function highbyte() to separate the high side of the word (bits 15~8) into a byte variable called data.

We then use the bitwise AND and OR operators to set the parameter bits 15~12. Then this byte is sent to the SPI bus. Finally, the function lowbyte() is used to send the low side of the word (bits 7~0) into data and thence down the SPI bus as well.

Now for our demonstration sketch (download):

Example 36.2

/*
 Example 36.2 - SPI bus device demo using a Microchip MCP4921 DAC [http://bit.ly/j3TSak]
 http://tronixstuff.com/tutorials > chapter 36 | CC by-sa-nc | John Boxall
 */

#include "SPI.h" // necessary library
int del=0; // used for various delays
word outputValue = 0; // a word is a 16-bit number
byte data = 0; // and a byte is an 8-bit number
void setup()
{
  //set pin(s) to input and output
  pinMode(10, OUTPUT);
  SPI.begin(); // wake up the SPI bus.
  SPI.setBitOrder(MSBFIRST);
}

void loop()
{
  for (int a=0; a<=4095; a++)
  {
    outputValue = a;
    digitalWrite(10, LOW);
    data = highByte(outputValue);
    data = 0b00001111 & data;
    data = 0b00110000 | data;
    SPI.transfer(data);
    data = lowByte(outputValue);
    SPI.transfer(data);
    digitalWrite(10, HIGH);
    delay(del);
  }
  delay(del+25);
  for (int a=4095; a>=0; --a)
  {
    outputValue = a;
    digitalWrite(10, LOW);
    data = highByte(outputValue);
    data = 0b00001111 & data;
    data = 0b00110000 | data;
    SPI.transfer(data);
    data = lowByte(outputValue);
    SPI.transfer(data);
    digitalWrite(10, HIGH);
    delay(del);
  }
  delay(del+25);
}

And a quick look at the DAC in action via an oscilloscope:

By now we have covered in detail how to send data to a device on the SPI bus. But how do we receive data from a device?

Doing so is quite simple, but some information is required about the particular device. For the rest of this chapter, we will use the Maxim DS3234 ”extremely accurate” real-time clock. Please download the data sheet (.pdf) now, as it will be referred to many times.

The DS3234 is not available in through-hole packaging, so we will be using one that comes pre-soldered onto a very convenient breakout board:

It only takes a few moments to solder in some header pins for breadboard use. The battery type is CR1220 (12 x 2.0mm, 3V); if you don’t have a battery you will need to short out the battery holder with some wire otherwise the IC will not work. Readers have reported that the IC doesn’t keep time if the USB and external power are both applied to the Arduino at the same time.

A device will have one or more registers where information is read from and written to. Look at page twelve of the DS3234 data sheet, there are twenty-three registers, each containing eight bits (one byte) of data. Please take note that each register has a read and write address. An example – to retrieve the contents of the register at location 08h (alarm minutes) and place it into the byte data we need to do the following:

  digitalWrite(10, LOW); // select the DS3234 that has its CS line on digital 10
  SPI.transfer(0x08); // tell the DS3234 device we're requesting data from the register at 08h
  data=SPI.transfer(0); // the DS3234 sends the data back and stores it in the byte data
  digitalWrite(10, HIGH);  // deselect the DS3234 if finished with it

Don’t forget to take note of the function SPI.setBitOrder(MSBFIRST); in your sketch, as this also determines the bit order of the data coming from the device.

To write data to a specific address is also quite simple, for example:

digitalWrite(10, LOW);
SPI.transfer(0x80); // tells the device which address to write to
SPI.transfer(b00001010);   // you can send any representation of a byte
digitalWrite(10, HIGH);

Up to this point, we have not concerned ourselves with what is called the SPI data mode. The mode determines how the SPI device interprets the ‘pulses’ of data going in and out of the device. For a well-defined explanation, please read this article. With some devices (and in our forthcoming example) the data mode needs to be defined. So we use:

SPI.setDataMode(SPI_MODE1);

to set the data mode, within void(setup);. To determine a device’s data mode, as always – consult the data sheet. With our DS3234 example, the mode is mentioned on page 1 under Features List.

Finally, let’s delve a little deeper into SPI via the DS3234. The interesting people at Sparkfun have already written a good demonstration sketch for the DS3234, so let’s have a look at that and deconstruct it a little to see what is going on. You can download the sketch below from here, then change the file extension from .c to .pde.

#include "SPI.h"
const int  cs=8; //chip select 

void setup() {
  Serial.begin(9600);
  RTC_init();
  //day(1-31), month(1-12), year(0-99), hour(0-23), minute(0-59), second(0-59)
  SetTimeDate(11,12,13,14,15,16);
}

void loop() {
  Serial.println(ReadTimeDate());
  delay(1000);
}
//=====================================
int RTC_init(){
	  pinMode(cs,OUTPUT); // chip select
	  // start the SPI library:
	  SPI.begin();
	  SPI.setBitOrder(MSBFIRST);
	  SPI.setDataMode(SPI_MODE1); // both mode 1 & 3 should work
	  //set control register
	  digitalWrite(cs, LOW);
	  SPI.transfer(0x8E);
	  SPI.transfer(0x60); //60= disable Osciallator and Battery SQ wave @1hz, temp compensation, Alarms disabled
	  digitalWrite(cs, HIGH);
	  delay(10);
}
//=====================================
int SetTimeDate(int d, int mo, int y, int h, int mi, int s){
	int TimeDate [7]={s,mi,h,0,d,mo,y};
	for(int i=0; i<=6;i++){
		if(i==3)
			i++;
		int b= TimeDate[i]/10;
		int a= TimeDate[i]-b*10;
		if(i==2){
			if (b==2)
				b=B00000010;
			else if (b==1)
				b=B00000001;
		}
		TimeDate[i]= a+(b<<4);

		digitalWrite(cs, LOW);
		SPI.transfer(i+0x80);
		SPI.transfer(TimeDate[i]);
		digitalWrite(cs, HIGH);
  }
}
//=====================================
String ReadTimeDate(){
	String temp;
	int TimeDate [7]; //second,minute,hour,null,day,month,year
	for(int i=0; i<=6;i++){
		if(i==3)
			i++;
		digitalWrite(cs, LOW);
		SPI.transfer(i+0x00);
		unsigned int n = SPI.transfer(0x00);
		digitalWrite(cs, HIGH);
		int a=n & B00001111;
		if(i==2){
			int b=(n & B00110000)>>4; //24 hour mode
			if(b==B00000010)
				b=20;
			else if(b==B00000001)
				b=10;
			TimeDate[i]=a+b;
		}
		else if(i==4){
			int b=(n & B00110000)>>4;
			TimeDate[i]=a+b*10;
		}
		else if(i==5){
			int b=(n & B00010000)>>4;
			TimeDate[i]=a+b*10;
		}
		else if(i==6){
			int b=(n & B11110000)>>4;
			TimeDate[i]=a+b*10;
		}
		else{
			int b=(n & B01110000)>>4;
			TimeDate[i]=a+b*10;
			}
	}
	temp.concat(TimeDate[4]);
	temp.concat("/") ;
	temp.concat(TimeDate[5]);
	temp.concat("/") ;
	temp.concat(TimeDate[6]);
	temp.concat("     ") ;
	temp.concat(TimeDate[2]);
	temp.concat(":") ;
	temp.concat(TimeDate[1]);
	temp.concat(":") ;
	temp.concat(TimeDate[0]);
  return(temp);
}

Don’t let the use of custom functions and loops put you off, they are there to save time. Looking in the function SetTimeDate();, you can see that the data is written to the registers 80h through to 86h (skipping 83h – day of week) in the way as described earlier (set CS low, send out address to write to, send out data, set CS high). You will also notice some bitwise arithmetic going on as well. This is done to convert data between binary-coded decimal and decimal numbers.

Why? Go back to page twelve of the DS3234 data sheet and look at (e.g.) register 00h/80h – seconds. The bits 7~4 are used to represent the ‘tens’ column of the value, and bits 3~0 represent the ‘ones’ column of the value. So some bit shifting is necessary to isolate the digit for each column in order to convert the data to decimal. For other ways to convert between BCD and decimal, see the examples using the Maxim DS1307 in chapter seven.

Finally here is another example of reading the time data from the DS3234 (download):

/*
 Example 36.3 - SPI bus device demo using a Maxim IC DS3234 Accurate RTC
 http://tronixstuff.com/tutorials > chapter 36 | CC by-sa-nc | John Boxall
 */

#include "SPI.h" // necessary library
// store hours, minutes, seconds, day of month, month, year
byte h,m,s,d,mo,y;

void setup() 
{
 pinMode(10, OUTPUT);
 SPI.begin(); // wake up the SPI bus.
 SPI.setBitOrder(MSBFIRST);
 SPI.setDataMode(SPI_MODE1); 
 digitalWrite(10, LOW); 

 SPI.transfer(0x8E); // write to control register 8Eh (page 14 data sheet)
 SPI.transfer(0x60); // oscillator on, 1Hz, alarms off (b01100000)
 digitalWrite(10, HIGH);

 Serial.begin(9600);
}

void readDS3234() 
{
 byte data=0;
 int a,b=0;
 digitalWrite(10, LOW);

 // get seconds
 SPI.transfer(0x00); // get seconds data from register 00h
 data=SPI.transfer(0x00);
 a = data & B00001111; // isolates 1's column
 b = (data & B01110000)>>4; // isolates 10's digit
 s=(b*10)+a; // calculate seconds!

 // get minutes
 SPI.transfer(0x01); // get minutes data from register 00h
 data=SPI.transfer(0x00);
 a = data & B00001111; // isolates 1's column
 b = (data & B01110000)>>4; // isolates 10's digit
 m=(b*10)+a; // calculate minutes!

 // get hours
 SPI.transfer(0x02); // get minutes data from register 00h
 data=SPI.transfer(0x00);
 a = data & B00001111; // isolates 1's column
 b = (data & B00110000)>>4; // isolate upper nibble
 if (b==B00000010) // 24 hr time
 { 
 b=20;
 } else
 if (b==B00000001) // 12 hr time
 {
 b=10;
 }
 h = a + b; // calculate hours

 digitalWrite(10, HIGH);
}

void loop()
{
 readDS3234();
 Serial.print(h, DEC);
 Serial.print(":");
 if (m<10)
 {
 Serial.print("0");
 }
 Serial.print(m, DEC);
 Serial.print(":");
 if (s<10)
 {
 Serial.print("0");
 }
 Serial.print(s, DEC);
 Serial.println();
 delay(500);
}

So there you have it – more about the world of the SPI bus and how to control the devices within.

June 15, 2011 Posted by John Boxall | arduino, BOB-10160, dac, education, learning electronics, microcontrollers, SPI, tutorial, Uncategorized | 10k, 1280, 2560, analog, analogue, arduino, bob-10160, bus, clock, converter, CS, dac, data, devices, digital, DIY, ds3234, duemilanove, eleven, fade, freetronics, how, interface, learn, lesson, lessons, master, max, maxim, MCP4162, MCP4921, mega, microchip, microvolts, millivolts, MISO, MOSI, multiple, mV, ohm, pinout, pot, potentiometer, pulse, PWM, real, RTC, SCK, sheet, slave, SPI, SS, synchronous, time, to, tronixstuff, tutorial, tutorials, understand, uno, uV | 6 Comments

Tutorial: Arduino and the SPI bus

Learn how to use the SPI data bus with Arduino in chapter thirty-four of a series originally titled “Getting Started/Moving Forward with Arduino!” by John Boxall – A seemingly endless tutorial on the Arduino universe. The first chapter is here, the complete series is detailed here.

[Updated 10/01/2013]

This is the first of two chapters in which we are going to start investigating the SPI data bus, and how we can control devices using it with our Arduino systems. The SPI bus may seem to be a complex interface to master, however with some brief study of this explanation and practical examples you will soon become a bus master! To do this we will learn the necessary theory, and then apply it by controlling a variety of devices. In this tutorial things will be kept as simple as possible.

But first of all, what is it? And some theory…

SPI is an acronym for “Serial Peripheral Interface”. It is a synchronous serial data bus – data can travel in both directions at the same time, as opposed to (for example) the I2C bus that cannot do so. To allow synchronous data transmission, the SPI bus uses four wires. They are called:

MOSI – Master-out, Slave-in. This line carries data from our Arduino to the SPI-controlled device(s);
MISO – Master-in, Slave out. This line carries data from the SPI-controlled device(s) back to the Arduino;
SS – Slave-select. This line tells the device on the bus we wish to communicate with it. Each SPI device needs a unique SS line back to the Arduino;
SCK – Serial clock.

Within these tutorials we consider the Arduino board to be the master and the SPI devices to be slaves. On our Arduino Duemilanove/Uno and compatible boards the pins used are:

SS – digital 10. You can use other digital pins, but 10 is generally the default as it is next to the other SPI pins;
MOSI – digital 11;
MISO – digital 12;
SCK – digital 13;

Arduino Mega users – MISO is 50, MOSI is 51, SCK is 52 and SS is usually 53. If you are using an Arduino Leonardo, the SPI pins are on the ICSP header pins. See here for more information. You can control one or more devices with the SPI bus. For example, for one device the wiring would be:

Data travels back and forth along the MOSI and MISO lines between our Arduino and the SPI device. This can only happen when the SS line is set to LOW. In other words, to communicate with a particular SPI device on the bus, we set the SS line to that device to LOW, then communicate with it, then set the line back to HIGH. If we have two or more SPI devices on the bus, the wiring would resemble the following:

Notice how there are two SS lines – we need one for each SPI device on the bus. You can use any free digital output pin on your Arduino as an SS line. Just remember to have all SS lines high except for the line connected to the SPI device you wish to use at the time.

Data is sent to the SPI device in byte form. You should know by now that eight bits make one byte, therefore representing a binary number with a value of between zero and 255. When communicating with our SPI devices, we need to know which way the device deals with the data – MSB or LSB first. MSB (most significant bit) is the left-hand side of the binary number, and LSB (least significant bit) is the right-hand side of the number. That is:

Apart from sending numerical values along the SPI bus, binary numbers can also represent commands. You can represent eight on/off settings using one byte of data, so a device’s parameters can be set by sending a byte of data. These parameters will vary with each device and should be illustrated in the particular device’s data sheet. For example, a digital potentiometer IC with six pots:

This device requires two bytes of data. The ADDR byte tells the device which of six potentiometers to control (numbered 0 to 5), and the DATA byte is the value for the potentiometer (0~255). We can use integers to represent these two values. For example, to set potentiometer number two to 125, we would send 2 then 125 to the device.

How do we send data to SPI devices in our sketches?

First of all, we need to use the SPI library. It is included with the default Arduino IDE installation, so put the following at the start of your sketch:

#include "SPI.h"

Next, in void.setup() declare which pin(s) will be used for SS and set them as OUTPUT. For example,

    pinMode(ss, OUTPUT);

where ss has previously been declared as an integer of value ten. Now, to activate the SPI bus:

SPI.begin();

and finally we need to tell the sketch which way to send data, MSB or LSB first by using

SPI.setBitOrder(MSBFIRST);

    SPI.setBitOrder(LSBFIRST);

When it is time to send data down the SPI bus to our device, three things need to happen. First, set the digital pin with SS to low:

digitalWrite(SS, LOW);

Then send the data in bytes, one byte at a time using:

SPI.transfer(value);

Value can be an integer/byte between zero and 255. Finally, when finished sending data to your device, end the transmission by setting SS high:

digitalWrite(ss, HIGH);

Sending data is quite simple. Generally the most difficult part for people is interpreting the device data sheet to understand how commands and data need to be structured for transmission. But with some practice, these small hurdles can be overcome.

Now for some practical examples!

Time to get on the SPI bus and control some devices. By following the examples below, you should gain a practical understanding of how the SPI bus and devices can be used with our Arduino boards.

Example 34.1

Our first example will use a simple yet interesting part – a digital potentiometer (we also used one in the I2C tutorial). This time we have a Microchip MCP4162-series 10k rheostat:

Here is the data sheet.pdf for your perusal. To control it we need to send two bytes of data – the first byte is the control byte, and thankfully for this example it is always zero (as the address for the wiper value is 00h [see table 4-1 of the data sheet]). The second byte is the the value to set the wiper, which controls the resistance. So to set the wiper we need to do three things in our sketch…

First, set the SS (slave select) line to low:

digitalWrite(10, LOW);

Then send the two byes of data:

SPI.transfer(0); // command byte

SPI.transfer(value); // wiper value

Finally set the SS line back to high:

digitalWrite(10, HIGH);

Easily done. Connection to our Arduino board is very simple – consider the MCP4162 pinout:

Vdd connects to 5V, Vss to GND, CS to digital 10, SCK to digital 13, SDI to digital 11 and SDO to digital 12. Now let’s run through the available values of the MCP4162 in the following sketch (download):

/*
 Example 34.1 - SPI bus demo using a Microchip MCP4162 digital potentiometer [http://bit.ly/iwDmnd]
 http://tronixstuff.com/tutorials > chapter 34 | CC by-sa-nc | John Boxall
*/

#include "SPI.h" // necessary library
int ss=10; // using digital pin 10 for SPI slave select
int del=200; // used for various delays

void setup()
{
  pinMode(ss, OUTPUT); // we use this for SS pin
  SPI.begin(); // wake up the SPI bus.
  SPI.setBitOrder(MSBFIRST);
  // our MCP4162 requires data to be sent MSB (most significant byte) first
}

void setValue(int value)
{
  digitalWrite(ss, LOW);
  SPI.transfer(0); // send command byte
  SPI.transfer(value); // send value (0~255)
  digitalWrite(ss, HIGH);
}

void loop()
{
  for (int a=0; a<256; a++)
  {
    setValue(a);
    delay(del);
  }
  for (int a=255; a>=0; --a)
  {
    setValue(a);
    delay(del);
  }
}

Now to see the results of the sketch. In the following video clip, a we run up through the resistance range and measure the rheostat value with a multimeter:

Before moving forward, if digital potentiometers are new for you, consider reading this short guide written by Microchip about the differences between mechanical and digital potentiometers.

Example 34.2

In this example, we will use the Analog Devices AD5204 four-channel digital potentiometer (data sheet.pdf). It contains four 10k ohm linear potentiometers, and each potentiometer is adjustable to one of 256 positions. The settings are volatile, which means they are not remembered when the power is turned off. Therefore when power is applied the potentiometers are all pre set to the middle of the scale. Our example is the SOIC-24 surface mount example, however it is also manufactured in DIP format as well.

To make life easier it can be soldered onto a SOIC breakout board which converts it to a through-hole package:

In this example, we will control the brightness of four LEDs. Wiring is very simple. Pinouts are in the data sheet.pdf.

And the sketch (download):

// Example 34.2 - SPI bus demo using Analog Devices AD5204 digital potentiometer

#include <SPI.h> // necessary library
int ss=10; // using digital pin 10 for SPI slave select
int del=5; // used for fading delay

void setup()
{
 pinMode(ss, OUTPUT); // we use this for SS pin
 SPI.begin(); // wake up the SPI bus. 
 SPI.setBitOrder(MSBFIRST); 
 // our AD5204 requires data to be sent MSB (most significant byte) first. See data sheet page 5
 allOff(); // we do this as pot memories are volatile
}

void allOff()
// sets all potentiometers to minimum value
{
 for (int z=0; z<4; z++)
 {
 setPot(z,0);
 }
}

void allOn()
// sets all potentiometers to maximum value
{
 for (int z=0; z<4; z++)
 {
 setPot(z,255);
 }
}

void setPot(int pot, int level)
// sets potentiometer 'pot' to level 'level'
{
 digitalWrite(ss, LOW);
 SPI.transfer(pot);
 SPI.transfer(level);
 digitalWrite(ss, HIGH);
}

void blinkAll(int count)
{
 for (int z=0; z

void indFade()
{
 for (int a=0; a<4; a++)
 {
 for (int l=0; l<255; l++)
 {
 setPot(a,l);
 delay(del);
 }
 for (int l=255; l>=0; --l)
 {
 setPot(a,l);
 delay(del);
 }
 }
}

void allFade(int count)
{
 for (int a=0; a<count; a++)="" {="" for="" (int="" l="0;" l<255;="" l++)="" setpot(0,l);="" setpot(1,l);="" setpot(2,l);="" setpot(3,l);="" delay(del);="" }="">=0; --l)
 {
 setPot(0,l);
 setPot(1,l);
 setPot(2,l); 
 setPot(3,l); 
 delay(del);
 }
 }
}

void loop()
{
 blinkAll(3);
 delay(1000);
 indFade();
 allFade(3);
}

The function allOff() and allOn() are used to set the potentiometers to minimum and maximum respectively. We use allOff() at the start of the sketch to turn the LEDs off. This is necessary as on power-up the wipers are generally set half-way. Furthermore we use them in the blinkAll() function to … blink the LEDs. The function setPot() accepts a wiper number (0~3) and value to set that wiper (0~255). Finally the function indFade() does a nice job of fading each LED on and off in order – causing an effect very similar to pulse-width modulation.

Finally, here it is in action:

Example 34.3

In this example, we will use use a four-digit, seven-segment LED display that has an SPI interface. Using such a display considerably reduces the amount of pins required on the micro controller and also negates the use of shift register ICs which helps reduce power consumption and component count. The front of our example:

and the rear:

Thankfully the pins are labelled quite clearly. Please note that the board does not include header pins – they were soldered in after receiving the board. Although this board is documented by Sparkfun there seems to be issues in the operation, so instead we will use a sketch designed by members of the Arduino forum. Not wanting to ignore this nice piece of hardware we will see how it works and use it with the new sketch from the forum.

Again, wiring is quite simple:

Board GND to Arduino GND
Board VCC to Arduino 5V
Board SCK to Arduino D12
Board SI to Arduino D11
Board CSN to Arduino D10

The sketch is easy to use, you need to replicate all the functions as well as the library calls and variable definitions. To display numbers (or the letters A~F) on the display, call the function

write_led(a,b,c);

where a is the number to display, b is the base system used (2 for binary, 8 for octal, 10 for usual, and 16 for hexadecimal), and c is for padded zeros (0 =off, 1=on). If you look at the void loop() part of the example sketch, we use all four number systems in the demonstration. If your number is too large for the display, it will show OF for overflow. To control the decimal points, colon and the LED at the top-right the third digit, we can use the following:

  write_led_decimals(1); // left-most decimal point
  write_led_decimals(2);
  write_led_decimals(4);
  write_led_decimals(8); // right-most decimal point
  write_led_decimals(16); // colon LEDs
  write_led_decimals(32); // apostrophe LED
  write_led_decimals(0); // off

After all that, here is the demonstration sketch for your perusal (download):

/*
 Example 34.3 - SPI bus demo using SFE 4-digit LED display [http://bit.ly/ixQdbT]
 http://tronixstuff.com/tutorials > chapter 34
 Based on code by Quazar & Busaboi on Arduio forum - http://bit.ly/iecYBQ
*/

#define DATAOUT 11 //MOSI
#define DATAIN 12 //MISO - not used, but part of builtin SPI
#define SPICLOCK 13 //sck
#define SLAVESELECT 10 //ss

char spi_transfer(volatile char data)
{
 SPDR = data; // Start the transmission
 while (!(SPSR & (1<
 {
 };
 return SPDR; // return the received byte
}

void setup()
{
 byte clr;
 pinMode(DATAOUT, OUTPUT);
 pinMode(DATAIN, INPUT);
 pinMode(SPICLOCK, OUTPUT);
 pinMode(SLAVESELECT, OUTPUT);
 digitalWrite(SLAVESELECT, HIGH); //disable device
 SPCR = (1<
 clr=SPSR;
 clr=SPDR;
 delay(10);
 write_led_numbers(0x78,0x78,0x78,0x78); //Blank display
 write_led_decimals(0x00); // All decimal points off
}

void write_led_decimals(int value)
{
 digitalWrite(SLAVESELECT, LOW);
 delay(10);
 spi_transfer(0x77); // Decimal Point OpCode
 spi_transfer(value); // Decimal Point Values
 digitalWrite(SLAVESELECT, HIGH); //release chip, signal end transfer
}
void write_led_numbers(int digit1, int digit2, int digit3, int digit4)
{
 digitalWrite(SLAVESELECT, LOW);
 delay(10);
 spi_transfer(digit1); // Thousands Digit
 spi_transfer(digit2); // Hundreds Digit
 spi_transfer(digit3); // Tens Digit
 spi_transfer(digit4); // Ones Digit
 digitalWrite(SLAVESELECT, HIGH); //release chip, signal end transfer
}

void write_led(unsigned short num, unsigned short base, unsigned short pad)
{
 unsigned short digit[4] = { 
 0, ' ', ' ', ' ' };
 unsigned short place = 0;

if ( (base<2) || (base>16) || (num>(base*base*base*base-1)) ) {
 write_led_numbers(' ', 0x00, 0x0f, ' '); // indicate overflow
 } 
 else {
 while ( (num || pad) && (place<4) ) {
 if ( (num>0) || pad )
 digit[place++] = num % base;
 num /= base;
 }
 write_led_numbers(digit[3], digit[2], digit[1], digit[0]);
 }
}

void pointDemo()
{
 write_led_decimals(1); 
 delay(1000);
 write_led_decimals(2);
 delay(1000);
 write_led_decimals(4);
 delay(1000);
 write_led_decimals(8);
 delay(1000);
 write_led_decimals(16);
 delay(1000);
 write_led_decimals(32);
 delay(1000);
 write_led_decimals(0); // non-digits all off 
}

void loop()
{
 pointDemo();
 delay(500);
 for (int i = 0; i < 100; i++) {
 write_led (i,10,1);
 delay(25);
 }
 delay(500);
 for (int i = 100; i >=0; --i) {
 write_led (i,10,0);
 delay(25);
 }
 delay(500); // now binary
 for (int i = 0; i < 16; i++) {
 write_led (i,2,0);
 delay(100);
 }
 delay(500);
 for (int i = 15; i >=0; --i) {
 write_led (i,2,0);
 delay(100);
 }
 delay(500); // now octal
 for (int i = 0; i < 500; i++) {
 write_led (i,8,0);
 delay(50);
 }
 delay(500);
 // now hexadecimal
 for (int i = 20000; i < 22000; i++) {
 write_led (i,16,0);
 delay(50);
 }
 delay(500);
}

And a short video of the demonstration:

So there you have it – hopefully an easy to understand introduction to the world of the SPI bus and how to control the devices within. As always, now it is up to you and your imagination to find something to control or get up to other shenanigans. In the next SPI article we will look at reading and writing data via the SPI bus.

Otherwise, have fun, stay safe, be good to each other – and make something!

May 13, 2011 Posted by John Boxall | arduino, COM-09767, education, learning electronics, microcontrollers, SPI | 10k, 1280, 2560, 5204, ad5204, analog, arduino, bus, clock, COM-09767, com-11440, CS, data, devices, digital, DIY, duemilanove, fade, freetronics, guide, guides, how, interface, kitten, learn, lesson, lessons, master, mega, MISO, MOSI, ohm, pinout, pot, potentiometer, PWM, SCK, sheet, slave, SPI, SS, synchronous, to, tronixstuff, tutorial, tutorials, understand, uno | 23 Comments

Review – Agilent U1272A True-RMS Digital Multimeter

This is our review of the Agilent Technologies U1272A water and dust resistant digital multimeter. It’s an extremely well specifed instrument, and according to the Agilent promotional material a better alternative to the venerable Fluke 87V. We also have examined the Bluetooth module.

Initial impression

The retail box as always is impressive and well decorated. Opening it up reveals a range of items:

including the meter itself, a calibration certificate and calibration results sheet, probe set, thermocouple, quick start guide and four AAA cells. It was a little disappointing to not find alligator clip adaptors nor a carrying case. For those interested, a full range of documentation is available here.

The meter measures 207 x 92 x 59 mm (hwd) and is quite solid, not too heavy and surrounded by a good orange non-slip rubber layer. This no doubt helps provide some shock resistance, as this unit has survived a 2.5 meter drop from my ceiling to the concrete. It is refreshing to see that the keypad is laid out in an organised way, much better than the random-looking layout on the U1250 series:

The meter

Installing or changing the the battery (four AAA cells) is easily accomplished, and thankfully the fuses are also in the same compartment. The included AAA cells are thecheaper “GP brand”, and should do for the first few months. The dust and moisture protection is evident as shown by the o-ring seal around the perimeter of the compartment:

As mentioned earlier, the U1272A is water and dust resistant to IP54 specifications – 54 meaning “protected against dust limited ingress”/”protection against water sprayed from all directions – limited ingress permitted.”.

For more information about IP ratings and what they all mean, check out this IP-rating chart.

It is possible to turn the function selector with one hand whether you have the meter standing up or laying on your desk. The included test leads are just over 1200mm in length and are rated at Cat III 1000V, 15A. Two pairs of probes are included, with 4mm and 19mm tips:

Again, it is unfortunate that alligator-clip adaptors nor probes are included – these are very useful especially to those who are colourblind and need to sort resistors or measure tiny through-hole capacitors. Furthermore, a K-tyle thermocouple and non-compensation transfer adaptor are also included:

The thermocouple’s temperature range is -20~200 degrees Celsius, however with an optional thermocouple the maximum temperature can be increased to 1200 degrees C. As for the othermeasurement ranges, they are detailed in the data sheet which you can download here (.pdf).

Furthermore there is a diode test function, and a continuity beeper. The backlight also flashes when using the continuity function which would be very convenient for those working in a noise environment. There has been some discussion around various forums as to the speed of the continuity function, so here is a small video demonstration of it in action:

In use

Although readers would not have any problem using the meter without reading the manual, doing so will illustrate the particular features of the U1272A as well as operation of the menu system that allow various settings to be changed. These can include: beep frequency (!), backlight duration, data communication parameters, default temperature units, scale conversion values, and activating the low-pass filter available when measuring DC voltage and current.

At the risk of shortening the battery life, I extended the backlight duration immediately to thirty seconds; and set temperature units to degrees Celsius. When taking measurements that only require the main numeric display, the ambient temperature is shown in the secondary numeric display. I must admit to discovering another feature by accident, if the leads are in the current and COM terminals and you select a non-current measurement function – the meter will beep like crazy, blink the backlight and show an error message. This is useful when you’re tired and probably should be doing something else.

Measuring AC voltage provides various data upon request. Apart from the RMS voltage value, you can also turn on a low-pass filter which blocks unwanted voltage above 1 kHz.

The frequency measurement function allows the display the frequency, duty cycle and pulse-width when measuring AC or DC current or voltage. Furthermore, you can display both voltage/current and also display the frequency, pulse-width and duty cycle at the same time, for example:

In a previous article the U1272A was used to measure frequency and duty cycle, which you can observe in the following short clip:

Measuring DC voltage is straightforward, and there is also the option to measure both AC and DC components and display them combined or separately, for example:

You can also display voltage as a decibel value relative to 1 mW (dBm) or a reference value of 1V (dBv). And the dB reference impedance can also be set to fall between 1 and 9999 ohms. Another interesting voltage measurement function is “Zlow”. Using this function, the meter changes to a very low input impedance, and can remove “ghost” voltages from the measurement by dissipating the coupling voltage. This function can also be used to test if a battery is still usable, if the voltage of the battery under test decreases slowly, it doesn’t have the capacity to deliver the required voltage. However I wouldn’t put a battery under this test method for too long due to the meter acting close to a short circuit.

Measuring resistance is simply done with the U1272A, and for more precise measurements one can short the probes to measure their resistance then set a null point so your measurements will not be affected by probe resistance. There is also an Agilent feature called SmartOhm which can be used to remove unexpected DC voltages that can add errors to resistance measurements. You can also use SmartOhm to measure leakage current or reverse current for junction diodes. I look forward to spending more time examining SmartOhm.

Furthermore, one can also measure conductance (the reciprocal of resistance) which is measured in Siemens. According to the manual one can measure extremely high resistance values up to 100 gigaohms. Interesting.

Diode measurement works as expected, the standard setting displays the voltage drop across the diode. However by pressing Shift on the meter, you can use the “Auto-diode” function which forward and reverse bias simultaneously using both numeric displays. For example, measuring a 1N4004 diode produces the following display, the forward voltage and the Good/Not good result:

Measuring capacitance is also quite simple, and the manual recommends setting a null value while the probes are open to compensate for residual capacitance. Interestingly the LCD shows when it is charging and discharging the capacitor under test, using the following segments:

Temperature measurement is possible with the included thermocouple and adaptor. Note that the included K-type thermocouple is only rated for up to 200 degrees Celsius, however with an optional unit the meter can measure up to 1372 degrees C. The display can show Fahrenheit as well as Celsius. The meter also shows ambient temperature using the secondary numeric display when it is not in use with other measurement display functions. Finally, measuring AC or DC current is completed as expected, and as noted earlier when switching to another non-current function, the meter will remind you to change the positive lead.

Compared to other meters, there are a few things that irritated me slightly with this unit. The auto-ranging can be somewhat slower than other meters, especially the frequency measurement – it can take around four seconds to measure a constant frequency… my old Tektronix CFC-250 is faster than that. And the exclusion of alligator-clip adaptors and case was disappointing considering the price of the meter. However on a positive note, the meter is supplied with minimal paper documentation, and a full range of manuals, service guides and so on are available for download from the Agilent website.

Update – 14th June 2011

Turns out that many people had similar (and other problems) to myself with their U1272A. They can be solved by updating the firmware via the USB cable. Agilent will send owners of early versions with the affected firmware a free USB cable in order to fix it up. Download this .pdf file with the instructions on how to receive the cable.

Update – 20th June 2011

The USB>DMM cable has arrived and the firmware updated to v2.0. The meter now works as expected – very well. Kudos for Agilent for taking ownership of the problem and sorting it out so rapidly.

Over the last three months I have been using the U1272A and would call it a success. The dual line LCD display really is useful, as well as the low current measurement and especially the Zlow function. There is a short video you can watch that explains a few of the unique features very well. Furthermore, there is a distinct lack of fragility which gives you one less thing to worry about when looking after your tools. Finally there is also the data-logging, however this does require an optional cable. If you are in the market for a full-function electronics multimeter, put this meter on your evaluation list.

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

High resolution images are available from flickr.

[Disclaimer - the Agilent U1272A in this review is a sample made available by Agilent Technologies via element-14]

April 1, 2011 Posted by John Boxall | agilent, android, bluetooth, review, test equipment, tutorial, U1177A, U1272A | agilent, android, bluetooth, calibration, continuity, digital, dmm, dust, element-14, guide, guides, IP67, lesson, lessons, multimeter, resistant, review, RMS, test, tronixstuff, true, tutorial, tutorials, U1177A, U1272A, water | 2 Comments

Tutorial: Using analog input for multiple buttons

This is chapter twenty-five 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. Please note from November 1, 2010 files from tutorials will be found here.

[Updated 14/03/2013]

The purpose of this article is demonstrate how you can read many push buttons (used for user-input) using only one analog input pin. This will allow you to save digital I/O pins for other uses such as LCD modules and so on. Hopefully you recall how we used analogRead() in chapter one, and how we used a potentiometer to control menu options in exercise 10.1. For this article, we will be looking at reading individual presses, not simultaneous (i.e. detecting multiple button presses).

To recap, an analog input pin is connected to an analog to digital (ADC) converter in our Arduino’s microcontroller. It has a ten bit resolution, and can return a numerical value between 0 and 1023 which relates to an analog voltage being read of between 0 and 5 volts DC.

Example 25.1

With this sketch:

/*  Example 25.1 - Demonstrating analogRead()

http://tronixstuff.com/tutorials > chapter 25

CC by-sa-nc*/

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 2, 3);

int a=0;

void setup()

lcd.begin(20, 4);

pinMode(A5, INPUT_PULLUP);

void loop()

a = analogRead(5);

lcd.clear();

lcd.setCursor(0,0);

lcd.print("  analogRead() ");

lcd.setCursor(0,1);

lcd.print("  value is :");

lcd.print(a);

delay(250);

and in the following short video, we have demonstrated the possible values returned by measuring the voltage from the centre pin of a 10k ohm potentiometer, which is connected between 5V and GND:

As the potentiometer’s resistance decreases, the value returned by analogRead() increases. Therefore at certain resistance values, analogRead() will return certain numerical values. So, if we created a circuit with (for example) five buttons that allowed various voltages to be read by an analog pin, each voltage read would cause analogRead() to return a particular value. And thus we can read the status of a number of buttons using one analog pin.

Example 25.2

The following circuit is an example of using five buttons on one analog input, using the sketch from example 25.1:

And here it is in action:

Where is the current coming from? Using pinMode(A5, INPUT_PULLUP); turns on the internal pull-up resistor in the microcontroller, which gives us ~4.8V to use. Some of you may have notice that when the right-most button is pressed, there is a direct short between A5 and GND. When that button is depressed, the current flow is less than one milliamp due to the pull-up resistor protecting us from a short circuit. Also note that you don’t have to use A5, any analog pin is fine.

As shown in the previous video clip, the values returned by analogRead() were:

1023 for nothing pressed (default state)
454 for button one
382 for button two
291 for button three
168 for button four
0 for button five

So for our sketches to react to the various button presses, they need to make decisions based on the value returned by analogRead(). Keeping all the resistors at the same value gives us a pretty fair spread between values, however the values can change slightly due to the tolerance of resistors and parasitic resistance in the circuit.

So after making a prototype circuit, you should determine the values for each button, and then have your sketch look at a range of values when reading the analog pin. Doing so becomes more important if you are producing more than one of your project, as resistors of the same value from the same batch can still vary slightly.

Example 25.3

Using the circuit from example 25.2, we will use a function to read the buttons and return the button number for the sketch to act upon.

/*  Example 25.3 - Digital buttons with analog input 
http://tronixstuff.com/tutorials > chapter 25 CC by-sa-nc */
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 2, 3);
int a=0;
void setup()
{

lcd.begin(20, 4);

     pinMode(A5, INPUT_PULLUP); // sets analog pin for input 

} 

int readButtons(int pin)
 // returns the button number pressed, or zero for none pressed 
 // int pin is the analog pin number to read 
{

int b,c = 0;

c=analogRead(pin); // get the analog value  if (c>1000)

b=0; // buttons have not been pressed

}   else

if (c>440 && c<470)

b=1; // button 1 pressed

}     else

if (c<400 && c>370)

b=2; // button 2 pressed

}       else

if (c>280 && c<310)

b=3; // button 3 pressed

}         else

if (c>150 && c<180)

b=4; // button 4 pressed

}           else

if (c<20)

b=5; // button 5 pressed

return b;
}
void loop()
{

a=readButtons(5);

lcd.clear();

if (a==0) // no buttons pressed

lcd.setCursor(0,1);

lcd.print("Press a button");

}   else

if (a>0) // someone pressed a button!

lcd.setCursor(0,2);

lcd.print("Pressed button ");

lcd.print(a);

delay(1000); // give the human time to read LCD
}

And now our video demonstration:

So now you have a useful method for receiving input via buttons without wasting many digital input pins. I hope you found this article useful or at least interesting.

January 11, 2011 Posted by John Boxall | microcontrollers, learning electronics, arduino, tutorial | analog, analogRead, analogue, arduino, button, digital, guide, guides, input, ladder, lesson, lessons, parasitic, potentiometer, project, projects, read, resistance, resistor, tronixstuff, tutorial, tutorials | Leave a Comment

Tutorial: Arduino and the I2C bus – Part Two

The first chapter is here, the complete series is detailed here. Please note from November 1, 2010 files from tutorials will be found here.

[Updated 10/01/2013]

Today we are going to continue learning about the I2C bus and how it can work for us. If you have not already, please read and understand the first I2C article before continuing.

First of all, there are some limitations of I2C to take into account when designing your projects. One of these is the physical length of the SDA and SCL lines. If all your devices are on the same PCB, then there is nothing to worry about, however if your I2C bus is longer than around one metre, it is recommended that you use an I2C bus extender IC. These ICs reduce electrical noise over the extended-length bus runs and buffer the I2C signals to reduce signal degradation and chance of errors in the data. An example of such an IC is the NXP P82B715 (data sheet). Using a pair of these ICs, you can have cable runs of 20 to 30 metres, using shielded twisted-pair cable. Below is a good example of this, from the aforementioned NXP data sheet:

Several applications come to mind with an extended I2C bus, for example remote temperature monitoring using the the ST Microelectronics CN75 temperature sensor from part one; or controlling several I/O ports using an I2C expander without the expense or worry of using a wireless system. Speaking of which, let’s do that now…

Example 21.1

A very useful and inexpensive part is the PCF8574 I/O expander (data sheet.pdf). This gives us another eight outputs, in a very similar method to the 74HC595; or can be used as eight extra inputs. In fact, if you were to use more than one 74HC595 this IC might be preferable, as you can individually address each chip instead of having to readdress every IC in line as you would with shift registers. So how do we do this? First, let’s consult the pinout:

There should not be any surprises for you there. A2~A0 are used to select the last three bits of the device address, P0~P7 are the I/O pins, and INT is an interrupt output which we will not use. To address the PCF8574 we need two things, the device address, and a byte of data which represents the required output pin state. Huh? Consider:

So if we set pins A0 to A2 to GND, our device address in binary will be 0100000, or 0×20 in hexadecimal. And the same again to set the output pins, for example to turn them all on we send binary 0 in hexadecimal which is 0; or to have the first four on and the second four off, use 00001111 which is Ox0F. Hopefully you noticed that those last two values seemed backwards – why would we send a zero to turn all the pins on?

The reason is that the PCF8574 is a current sink. This means that current runs from +5v, through into the I/O pins. For example, an LED would have the anode on the +5V, and the cathode connected to an I/O pin. Normally (for example with a 74HC595) current would run from the IC, through the resistor, LED and then to earth. That is a current source. Consider the following quick diagram:

In the example above, please note that the PCF8574N can take care of current limitation with LEDs, whereas the 74HC595 needs a current-limiting resistor to protect the LED.

Luckily this IC can handle higher volumes of current, so a resistor will not be required. It sounds a bit odd, but like anything is easy once you spend a few moments looking into it. So now let’s use three PCF8574s to control 24 LEDs. To recreate this masterpiece of blinkiness you will need:

Arduino Uno/Duemilanove or Freetronics Eleven board
A large solderless breadboard
Three PCF8574 I/O extenders
Eight each of red, green and yellow (or your choice) LEDs, each with a current draw of no more than 20mA
Two 4.7 kilo ohm resistors
Hook-up wires
Three 0.1 uF ceramic capacitors

Here is the schematic:

… and the example board layout:

and the example sketch. Note that the device addresses in the sketch match the schematic above. If for some reason you are wiring your PCF8574s differently, you will need to recalculate your device addresses: (download sketch)

/*
 Example 21.1
 Texas Instruments PCF8574N demonstration sketch
 element-14 part number 7527718; RS part number 517-0687
 http://tronixstuff.com/tutorials > chapter 21
 CC by-sa v3.0
 */

#include "Wire.h"
#define redchip 0x20 // device addresses for PCF8547Ns on each LED colour bank 
#define yellowchip 0x22 // addresses in this example match the published schematic in the tutorial
#define greenchip 0x21 // you will need to change addresses if you vary from the schematic
int dd=20; // used for delay timing

void setup()
{
 Wire.begin();
 allOff(); // the PCF8574N defaults to high, so this functions turns all outputs off
}

// remember that the IC "sinks" current, that is current runs fro +5v through the LED and then to I/O pin
// this means that 'high' = off, 'low' = on.

void testfunc()
{
 Wire.beginTransmission(redchip);
 Wire.write(0); 
 Wire.endTransmission();
 delay(dd+50);
 Wire.beginTransmission(redchip);
 Wire.write(255); 
 Wire.endTransmission();
 delay(dd+50);
 Wire.beginTransmission(yellowchip);
 Wire.write(0); 
 Wire.endTransmission();
 delay(dd+50);
 Wire.beginTransmission(yellowchip);
 Wire.write(255); 
 Wire.endTransmission();
 delay(dd+50);
 Wire.beginTransmission(greenchip);
 Wire.write(0); 
 Wire.endTransmission();
 delay(dd+50);
 Wire.beginTransmission(greenchip);
 Wire.write(255); 
 Wire.endTransmission();
 delay(dd+50);
}

void testfunc2()
{
 for (int y=1; y<256; y*=2)
 {
 Wire.beginTransmission(redchip);
 Wire.write(255-y); // we need the inverse, that is high = off
 Wire.endTransmission();
 delay(dd);
 Wire.beginTransmission(redchip);
 Wire.write(255); 
 Wire.endTransmission();
 delay(dd);
 }

 for (int y=1; y<256; y*=2)
 {
 Wire.beginTransmission(yellowchip);
 Wire.write(255-y); 
 Wire.endTransmission();
 delay(dd);
 Wire.beginTransmission(yellowchip);
 Wire.write(255); 
 Wire.endTransmission();
 delay(dd);
 }
 for (int y=1; y<256; y*=2)
 {
 Wire.beginTransmission(greenchip);
 Wire.write(255-y); 
 Wire.endTransmission();
 delay(dd);
 Wire.beginTransmission(greenchip);
 Wire.write(255); 
 Wire.endTransmission();
 delay(dd);
 }
}

void testfunc3()
{
 Wire.beginTransmission(redchip);
 Wire.write(0); 
 Wire.endTransmission();
 Wire.beginTransmission(yellowchip);
 Wire.write(0); 
 Wire.endTransmission();
 Wire.beginTransmission(greenchip);
 Wire.write(0); 
 Wire.endTransmission();
 delay(dd+50);
 allOff();
 delay(dd+50);
}

void allOff()
{
 Wire.beginTransmission(redchip);
 Wire.write(255); 
 Wire.endTransmission();
 Wire.beginTransmission(yellowchip);
 Wire.write(255); 
 Wire.endTransmission();
 Wire.beginTransmission(greenchip);
 Wire.write(255); 
 Wire.endTransmission();
}

void loop()
{
 for (int z=0; z<10; z++)
 {
 testfunc();
 }
 for (int z=0; z<10; z++)
 {
 testfunc2();
 }
 for (int z=0; z<10; z++)
 {
 testfunc3();
 }
}

And finally our demonstration video:

That was a good example of controlling many outputs with our humble I2C bus. You could literally control hundreds of outputs if necessary – a quite inexpensive way of doing so. Don’t forget to take into account the total current draw of any extended circuits if you are powering from your Arduino boards.

The next devices to examine on our I2C bus ride are EEPROMs - Electrically Erasable Programmable Read-Only Memory. These are memory chips that can store data without requiring power to retain memory. Why would we want to use these? Sometimes you might need to store a lot of reference data for use in calculations during a sketch, such as a mathematical table; or perhaps numerical representations of maps or location data; or create your own interpreter within a sketch that takes instruction from data stored in an array.

In other words, an EEPROM can be used to store data of a more permanent use, ideal for when your main microcontroller doesn’t haven enough memory for you to store the data in the program code. However, EEPROMs are not really designed for random-access or constant read/write operations – they have a finite lifespan. But their use is quite simple, so we can take advantage of them.

EEPROMS, like anything else come in many shapes and sizes. The model we will examine today is the Microchip 24LC256 (data sheet.pdf). It can hold 256 kilobits of data (that’s 32 kilobytes) and is quite inexpensive. This model also has selectable device addresses using three pins, so we can use up to eight at once on the same bus. An example:

The pinouts are very simple:

Pin 7 is “write protect” – set this low for read/write or high for read only. You could also control this in software if necessary. Once again we need to create a slave I2C device address using pins 1, 2 and 3 – these correlate to A2, A1 and A0 in the following table:

So if you were just using one 24LC256, the easiest solution would be to set A0~A2 to GND – which makes your slave address 1010000 or 0×50 in hexadecimal. There are several things to understand when it comes to reading and writing our bytes of data. As this IC has 32 kilobytes of storage, we need to be able to reference each byte in order to read or write to it. There is a slight catch in that you need more than one byte to reference 32767 (as in binary 32767 is 11111111 0100100 [16 bits]).

So when it comes time to send read and write requests, we need to send two bytes down the bus – one representing the higher end of the address (the first 8 bits from left to right), and the next one representing the lower end of the address (the final 8 bits from left to right) – see figure 6.1 on page 9 of the data sheet.

An example – we need to reference byte number 25000. In binary, 25000 is 0110000110101000. So we split that up into 01100001 and 10101000, then covert the binary values to numerical bytes with which to send using the Wire.send(). Thankfully there are two operators to help us with this. This first is >>, known as bitshift right. This will take the higher end of the byte and drop off the lower end, leaving us with the first 8 bits. To isolate the lower end of the address, we use another operator &, known as bitwise and. This unassuming character, when used with 0XFF can separate the lower bits for us. This may seem odd, but will work in the examples below.

Writing data to the 24LC256

Writing data is quite easy. But first remember that a byte of data is 11111111 in binary, or 255 in decimal. First we wake up the I2C bus with

Wire.beginTransmission(0x50); // if pins A0~A2 are set to GND

then send down some data. The first data are the two bytes representing the address (25000) of the byte (12) we want to write to the memory.

Wire.write(25000 >> 8);  // send the left-hand side of the address down

Wire.write(25000 & 0xFF); // send the right-hand side of the address down

And finally, we send the byte of data to store at address 25000, then finish the connection:

Wire.write(12);

Wire.endTransmission();

There we have it. Now for getting it back…

Reading data from the 24LC256

Reading is quite similar. First we need to start things up and move the pointer to the data we want to read:

Wire.beginTransmission(0x50); // if pins A0~A2 are set to GND

Wire.write(25000 >> 8);  // send the left-hand side of the address down

Wire.write(25000 & 0xFF); // send the right-hand side of the address down

Wire.endTransmission();

Then, ask for the byte(s) of data starting at the current address:

Wire.beginTransmission(0x50); // if pins A0~A2 are set to GND

Wire.requestFrom(0x50,1);

Wire.read(incomingbyte);

In this example, incomingbyte is a byte variable used to store the data we retrieved from the IC.

Example 21.2

Now we have the theory, let’s put it into practice with the test circuit below, which contains two 24LC256 EEPROMs. To recreate this you will need:

Arduino Uno or Freetronics Eleven board
A large solderless breadboard
Two Microchip 24LC256 EEPROMs
Two 4.7 kilo ohm resistors
Hook-up wires
Two 0.1 uF ceramic capacitors

Here is the schematic:

… the board layout:

and the example sketch. Note that the device addresses in the sketch match the schematic above. If for some reason you are wiring your 24LC256s differently, you will need to recalculate your device addresses. To save time with future coding, we have our own functions for reading and writing bytes to the EEPROM – readData() and writeData(). Consider the sketch for our example: (download sketch)

/*
 Example 21.2
 Reading and writing data to Microchip 24LC256 EEPROMS over I2C
 tronixstuff.com/tutorials > Chapter 21
 CC by-sa v3.0 
*/

#include  // for I2C
#define chip1 0x50 // device address for left-hand chip on our breadboard
#define chip2 0x51 // and the right

// always have your values in variables
unsigned int pointer = 69; // we need this to be unsigned, as you may have an address > 32767
byte d=0; // example variable to handle data going in and out of EERPROMS

void setup()
{
 Serial.begin(9600); // for screen output
 Wire.begin(); // wake up, I2C!
}

void writeData(int device, unsigned int add, byte data) 
// writes a byte of data 'data' to the chip at I2C address 'device', in memory location 'add'
{
 Wire.beginTransmission(device);
 Wire.write((int)(add >> 8)); // left-part of pointer address
 Wire.write((int)(add & 0xFF)); // and the right
 Wire.write(data);
 Wire.endTransmission();
 delay(10);
}

byte readData(int device, unsigned int add) 
// reads a byte of data from memory location 'add' in chip at I2C address 'device' 
{
 byte result; // returned value
 Wire.beginTransmission(device); // these three lines set the pointer position in the EEPROM
 Wire.write((int)(add >> 8)); // left-part of pointer address
 Wire.write((int)(add & 0xFF)); // and the right
 Wire.endTransmission();
 Wire.requestFrom(device,1); // now get the byte of data...
 result = Wire.read();
 return result; // and return it as a result of the function readData
}

void loop()
{
 Serial.println("Writing data...");
 for (int a=0; a<20; a++)
 {
 writeData(chip1,a,a);
 writeData(chip2,a,a); // looks like a tiny EEPROM RAID solution!
 }
 Serial.println("Reading data...");
 for (int a=0; a<20; a++)
 {
 Serial.print("chip1 pointer ");
 Serial.print(a);
 Serial.print(" holds ");
 d=readData(chip1,a);
 Serial.println(d, DEC);
 }
 for (int a=0; a<20; a++)
 {
 Serial.print("chip2 pointer ");
 Serial.print(a);
 Serial.print(" holds ");
 d=readData(chip2,a);
 Serial.println(d, DEC);
 } 
}

And the output from the example sketch:

Although the sketch in itself was simple, you now have the functions to read and write byte data to EEPROMS. Now it is up to your imagination to take use of the extra memory.

October 29, 2010 Posted by John Boxall | arduino, I2C, learning electronics, microcontrollers, tutorial | 24lc256, 24lc512, arduino, bus, digital, eeprom, example, expander, guide, guides, i/o, i2c, instruments, lesson, lessons, microchip, PCF8547, PCF8547N, texas, TI, tronixstuff, tutorial, tutorials | 11 Comments

« Previous Entries

YouTube

Visit tronixstuff on YouTube for our range of videos
Clock Projects

Zero - blinky the clock
One - DMD clock
Two - Single digit clock
Three - Pillow clock
Four - Scrolling text clock
Arduino Tutorials

Click for Detailed Chapter Index

Chapters 0 1 2 3 4
Chapters 5 6 6a 7 8
Chapters 9 10 11 12 13
Ch. 14 - XBee
Ch. 15 - RFID - RDM-630
Ch. 15a - RFID - ID-20
Ch. 16 - Ethernet
Ch. 17 - GPS part I
Ch. 18 - RGB matrix
Ch. 19 - GPS part II
Ch. 20 - I2C bus part I
Ch. 21 - I2C bus part II
Ch. 22 - AREF pin
Ch. 23 - Touch screen
Ch. 24 - Monochrome LCD
Ch. 25 - Analog buttons
Ch. 26 - Arduino + GSM - part I
Ch. 27 - Arduino + GSM - part II
Ch. 28 - Colour LCD
Ch. 29 - TFT LCD
Ch. 30 - Arduino + twitter
Ch. 31 - Inbuilt EEPROM
Ch. 32 - Infra-red control
Ch. 33 - Control AC via SMS
Ch. 34 - SPI bus part I
Ch. 35 - Video-out
Ch. 36 - SPI bus part II
Ch. 37 - Timing with millis()
Ch. 38 - Thermal Printer
Ch. 39 - NXP SAA1064
Ch. 40 - Push wheel switches
Ch. 40a - Wheel switches II
Ch. 41 - More digital I/O
Ch. 42 - Numeric keypads
Ch. 42a - Keypads II
Ch. 43 - Port Manipulation
Ch. 44 - ATtiny+Arduino
Ch. 45 - Ultrasonic Sensor
Ch. 46 - Analog + buttons II
Ch. 47 - Internet-controlled relays
Ch. 48 - MSGEQ7 Spectrum Analyzer
Arduino Due - first look
Ch. 49 - KTM-S1201 LCD modules
Ch. 50 - ILI9325 colour TFT LCD modules
Ch. 51 - MC14489 LED display driver IC
Search

Search for:
RSS Feeds

Subscribe in a reader
Join my update list!

Enter your email address to receive notifications of new posts by email.

Join 3,838 other followers
Categories
Previous posts

May 2013

M T W T F S S

« Apr

1 2 3 4 5

6 7 8 9 10 11 12

13 14 15 16 17 18 19

20 21 22 23 24 25 26

27 28 29 30 31
Archives
- May 2013
- April 2013
- March 2013
- February 2013
- January 2013
- October 2012
- September 2012
- June 2012
- May 2012
- April 2012
- March 2012
- February 2012
- January 2012
- December 2011
- November 2011
- October 2011
- September 2011
- August 2011
- July 2011
- June 2011
- May 2011
- April 2011
- March 2011
- February 2011
- January 2011
- December 2010
- November 2010
- October 2010
- September 2010
- August 2010
- July 2010
- June 2010
- May 2010
- April 2010
- March 2010

May 2013
M	T	W	T	F	S	S
« Apr
	1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31

Contact information

email - john at tronixstuff dot com
Google Group

Why not join our discussion group? Fun and learning with electronics!
Australian Electronics!

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

All the original material in this website, unless noted otherwise, is covered under a Creative Commons Attribution-Non Commercial-Share Alike v3.0 license. Please email me if you see any mis-attributions or would like to use my content in different circumstances.
on twitter…
- RT @freetronics: Mind-controlling microbes with an Arduino - freetronics.com/blogs/news/793… #arduino 53 minutes ago
- RT @MakerFaireMel: Ammon, James and Paul have been working on another event in Nov 2013. You can check out what we've been up to here: htt… 1 day ago
- RT @jonoxer Packaging for the new @freetronics Arduino-compatible RGB cube looks almost as good as the actual cube http://t.co/xXMb8HFbXw 2 days ago
- RT @jonoxer Awesome! Postie just delivered @tronixstuff's new #Arduino book. Looks great. #ArduinoWorkshop http://t.co/3nX0bWaxLi 2 days ago
- RT @jonoxer: Awesome! Postie just delivered @tronixstuff's new #Arduino book. Looks great. #ArduinoWorkshop http://t.co/5Bxq4bBn7r 2 days ago
Flickr Photos

More Photos
Find me on…

element 14
flickr
friendfeed
Google+
posterous
tumblr
Twitter
vimeo
Whirlpool
Youtube
Interesting Sites

David L. Jones' eev blog
Freetronics Arduino Geniuses!
Silicon Chip magazine Always a great read!
Amazing Arduino Shield Directory
The Amp Hour podcast
EEWeb Elec Engineering Forum
Superhouse.tv High-tech home renovation
Mr Dick Smith OA
Nuclear weapons = global suicide

In a war with nuclear weapons, everybody loses. Please check these out:
Count Down to Zero
The War Game
Threads

t r o n i x s t u f f

fun and learning with electronics

Kit Review – JYE Tech FG085 DDS Function Generator

Project: Clock Two – Single digit clock

Using an ATtiny as an Arduino

Review – Tenma 72-7222 Digital Clamp Multimeter

Tutorial: Arduino timing methods with millis()

Tutorial: Arduino and the SPI bus part II

Tutorial: Arduino and the SPI bus

Review – Agilent U1272A True-RMS Digital Multimeter

Tutorial: Using analog input for multiple buttons

Tutorial: Arduino and the I2C bus – Part Two

YouTube

Clock Projects

Arduino Tutorials

Search

RSS Feeds

Join my update list!

Categories

Previous posts

Archives

Contact information

Google Group

Australian Electronics!

Creative Commons

on twitter…

Flickr Photos

Find me on…

Interesting Sites

Nuclear weapons = global suicide

Site info

Follow “t r o n i x s t u f f”

fun and learning with electronics

Please share with others:

Like this:

Please share with others:

Like this:

Please share with others:

Like this:

Please share with others:

Like this:

Please share with others:

Like this:

Please share with others:

Like this:

Please share with others:

Like this:

Please share with others:

Like this:

Please share with others:

Like this:

Please share with others:

Like this:

YouTube

Clock Projects

Arduino Tutorials

Search

RSS Feeds

Join my update list!

Categories

Previous posts

Archives

Contact information

Google Group

Australian Electronics!

Creative Commons

Flickr Photos

Find me on…

Interesting Sites

Nuclear weapons = global suicide

Site info

Follow “t r o n i x s t u f f”