tronixstuff

Experimenting with Surface-Mount Component Prototyping

2012-02-11T23:42:00.001-08:00

Now and again I have looked at SMT (surface-mount technology) components and thought to myself “I should try that one day”. But not wanting to fork out for a toaster oven and a bunch of special tools I did it on the cheap – so in this article you can follow along and see the results. Recently I ordered some ElecFreaks SOIC Arduino Mega-style protoshields which apart from being a normal double-sided protoshield, also have a SOIC SMT pad as shown below:

First up I soldered in two SOIC format ICs – a 555 and a 4017:

These were not that difficult – you need a steady hand, a clean soldering iron tip and some blu-tac. To start, stick down the IC as such:

… then you can … very carefully … hand-solder in a few legs, remove the blu tac and take care of the rest …

The 4017 went in easily as well…

…however it can be easier to flood the pins with solder, then use solder-wick to soak up the excess – which in theory will remove the bridges between pins caused by the excess solder. And some PCB cleaner to get rid of the excess flux is a good idea as well.

Now to some smaller components – some LEDs and a resistor. These were 0805 package types, which measure 2.0 × 1.3 mm – for example a resistor:

The LEDs were also the same size. Unlike normal LEDs, determining the anode and cathode can be difficult – however my examples had a small arrow determining current flow (anode to cathode) on the bottom:

Another way is to use the continuity function of a multimeter – if their output voltage is less than the rating of the LED, you can probe it to determine the pins. When it glows, the positive lead is the anode. Handling such small components requires the use of anti-magnetic tweezers – highly recommended…

… and make holding down the components with one hand whilst soldering with the other much, much easier.

Unlike normal veroboard, protoshield or other prototyping PCBs the protoshield’s holes are surrounded with a “clover” style of solder pad, for example:

These solder pads can make hand-soldering SMT parts a little easier. After some experimenting, I found the easiest way was to first flood the hold with solder:

… then hold down the component with the tweezers with one hand while heating the solder with the other – then moving and holding one end of the component into the molten solder:

Question - What are the dimensions (length x width) of an 0805 SMT component in mm?

The first time (above) was a little messy, but one improves with practice. The clover-style of the solder pads makes it easy to connect two components, for example:

With some practice the procedure can become quite manageable:

As the protoshields are double-sided you can make connections between components on the other side to keep things neat for observers. To complete the experiment the six LEDs were wired underneath (except for one) to matching Arduino Mega digital output pins, and a simple demonstration sketch used to illuminate the LEDs, as shown below:

For one-off or very low-volume SMD work these shields from elecfreaks are quite useful. You will need a steady hand and quite a lot of patience, but if the need calls it would be handy to have some of these boards around just in case. For a more involved and professional method of working with SMT, check out this guide by Jon Oxer.

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, or join our Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other – and we can all learn something.

Posted via email from tronixstuff's posterous

February 2012 Competition

2012-02-10T02:08:00.001-08:00

It’s that time of the month again so we are running another competition. This month we have two prizes. Let’s check those out then follow up with the rules of entry.

Prize One is a brand new Freetronics EtherMega board – the mother of all Arduino-compatible boards. As reviewed recently, the EtherMegacombines the power and versatility of the Arduino Mega2560, a microSD card shield, a full Ethernet shield and power over Ethernet support:

From the Freetronics website:

The EtherMega is a 100% Arduino Mega 2560 compatible board that can talk to the world. Do Twitter updates automatically, serve web pages, connect to web services, display sensor data online, and control devices using a web browser. The Freetronics EtherMega uses the same ATmega2560 as the Arduino Mega 2560 so it has masses of RAM, flash memory, and I/O pins, and also includes the same Wiznet W5100 chip used by the official Arduino Ethernet Shield, so it’s 100% compatible with the Ethernet library and sketches.

Any project you would previously have built with an Arduino Mega 2560 and an Ethernet shield stacked together, you can now do all in a single, integrated board. We’ve even added a micro SD card slot so you can store web content on the card, or log data to it. But it gets even better: we found space to squeeze in a small prototyping area, so now it’s possible to build a complete, Internet-enabled Arduino device including your own custom parts all on a single board! You don’t even need to use a prototyping shield for many projects.

Prize Two is awesome – it has to be one of the most amazing developments in the Arduino world I have seen for a long time. However it’s so new it hasn’t been released for sale – yet. But we have one to give away, and when this product is released to the open market we’ll give you the full rundown on it:

The most annoying thing is that I have one of these right here in front of me, but can’t tell you anything about it. So stay tuned using the methods at the end of this post for more information when it becomes available.

How to enter!

There will be six questions for you to answer spread across articles published between the 1st and 29th of February. So you will need to review older posts. At the end of February and once you have answers to all six questions, email the answers along with your full name, email address and postal address to competition at tronixstuff dot com with the subject heading February.

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

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

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

Thanks to Freetronics for the EtherMega first prize!

So have fun and keep an eye out for the four competition questions spread through the February posts… In the meanwhile, 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.

Posted via email from tronixstuff's posterous

Review - Freetronics EtherMega

2012-02-07T07:21:00.001-08:00

In this review we take a look at what is possibly the most fully-featured Arduino compatible board on the market today - the Freetronics EtherMega. This board combines the functionality of an Arduino Mega2560, a microSD card shield, and an Ethernet shield that supports power over Ethernet with optional 802.3af standard. So instead of having these three mashed together at a great expense:

... you can have this:

Which saves space, time and money. Firstly, the specifications:

100% compatible with the Arduino Mega2560. So you have the ATmega2560 microcontroller, 54 digital I/O pins with 14 PWM-capable, 256KB of flash memory, 8KB of SRAM and 4KB of EEPROM to play with, the Atmel 8u2 micrcontroller taking care of the USB interface;
However unlike the original, the EtherMega contains a switchmode power supply that allows operation from a DC power supply of between 7 and 28VDC without overheating;
Complete c0mpatibility with the Arduino Ethernet shield, using the Wiznet W5100 controller just like the original;
Network status LEDs on both the socket and the PCB;
Fixed SPI behaviour on Ethernet chipset;
Complete microSD card compatibility with SD library, and chip-select is on digital pin 4 so Ethernet and microSD can work together on the same sketch;
optional 802.3af power over Ethernet support at up to 48V using the optional regulator board which mounts on the EtherMega;
mini USB connector instead of the larger standard USB socket which can interfere with shields - and a USB cable is included

Furthermore there are a few modifications to make using the EtherMega easier or simpler. The first of these is the onboard prototyping area allowing you to add your own circuitry, or perhaps a module:

Also notice that the I2C pins have been brought out alongside the 5V and GND pins on the right. The only difference to take note of are the jumpers that are used to select either USB or DC socket power:

However that is a small price to pay compared to the convenience of the wide voltage-handling capability. Finally, unlike the original Arduino Mega2560 the designers have placed the TX/RX indicators at the top-left of the EtherMega so they are still visible when extra shields have been mounted:

The overall design and quality of the EtherMega is top notch, with a thick PCB, rounded corners, descriptive silk-screening, and packaging that can be reused as Mega or other part storage.

If you are looking for an Arduino Mega2560 and could use Ethernet, power-over-Ethernet, a microSD card interface and full, 100% Arduino compatibility you could do a lot worse than getting yourself an EtherMega. If you are interested in learning how to use Arduino and Ethernet - check out our tutorial here. Or to get your Arduino tweeting, visit here. For more discussion and support information for the EtherMega consult the forum or product web page.

Disclaimer – The EtherMega board reviewed in this article was a promotional consideration made available by Freetronics.

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.

Posted via email from tronixstuff's posterous

Results – January 2012 Competition

2012-02-04T15:55:00.001-08:00

Hello Readers

The January 2012 competition has now closed. For the curious, the questions and answers were:

Q – What does the acronym PWM mean?
A – Pulse-width modulation

Q – How many LEDs are contained in the Freetronics DMD?
A – 512

Q – How many digital I/O pins on an Arduino Mega2560?
A – 54

Q – What type of processor core does the PIC32 (from the Uno32 review) use?
A – MIPS (or to be more precise, 32-bit MIPS M4K Core)

Congratulations to Jack M. from the interesting state of South Australia! Jack has won the following prizes:

One v1.0 Akafugu Akafuino-X board as reviewed recently:

Jack’s Akafuino-X will have a companion on its journey which will be the Mayhew Labs “Go Between” Shield, as reviewed recently:

Thanks to Akafugu for offering the Akafuino-X prize!

The February 2012 competition will be announced soon, so in the meanwhile have fun and 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.

Posted via email from tronixstuff's posterous

Project: Clock One

2012-02-01T06:23:00.001-08:00

Introduction

For some strange reason I have a fascination with various types of electronic clocks (which explains this article). Therefore this project will be the start of an irregular series of clock projects whose goal will be easy to follow and produce interesting results. Our “Clock One” will use a Freetronics Dot Matrix Display board as reviewed previously. Here is an example of an operating Clock One:

As you can see, on the left half of the board we have a representation of an analogue clock. Considering we only have sixteen rows of sixteen LEDs, it isn’t too bad at all. The seconds are illuminated by sixty pixels that circumnavigate the square clock throughout the minute. On the right we display the first two letters of the day of the week, and below this the date. In the example image above, the time is 6:08. We omitted the month – if you don’t know what month it is you have larger problems.

Hardware

To make this happen you will need:

A Freetronics Dot Matrix Display board;
If you want the run the display at full brightness (ouch!) you will need a 5V 2.8A power supply – however our example is running without the external supply and is pretty strong
An Arduino board of some sort, an Uno or Eleven is a good start
A Maxim DS1307 real-time clock IC circuit. How to build this is explained here. If you have a Freetronics board, you can add this circuit directly onto the board!

Software

Planning the clock was quite simple. As we can only draw lines, individual pixels, and strings of text or individual characters, some planning was required in order to control the display board. A simple method is to use some graph paper and note down where you want things and the coordinates for each pixel of interest, for example:

Using the plan you can determine where you want things to go, and then the coordinates for pixels, positions of lines and so on. The operation for this clock is as follows:

display the day of week
display the date
draw the hour hand
draw the minute hand
then turn on each pixel representing the seconds
after the 59th second, turn off the pixels on the left-hand side of the display (to wipe the clock face)

There isn’t a need to wipe the right hand side of the display, as the characters have a ‘clear’ background which takes care of this when updated. At this point you can download the Arduino sketch from here. Note that the sketch was written to get the job done and ease of reading and therefore not what some people would call efficient. Some assumed knowledge is required – to catch up on the use of the display, see here; and for DS1307 real-time clock ICs, see here.

The sketch uses the popular method of reading and writing time data to the DS1307 using functions setDateDs1307and getDateDs1307. You can initally set the time within void setup() – after uploading the sketch, comment out thesetDateDs1307 line and upload the sketch again, otherwise every time the board resets or has a power outage the time will revert to the originally-set point.

Each display function is individual and uses many switch…case statements to determine which line or pixel to draw. This was done again to draw the characters on the right due to function limitations with the display library. But again it works, so I’m satisfied with it. You are always free to download and modify the code yourself. Moving forward, here is a short video clip of the Clock One in action:

So there you have it, the first of many clocks I plan to describe in the future. For more information about the display used, please visit the Freetronics product page. Otherwise if you have any comments or suggestions, please leave them below or in ourGoogle Group.

Disclaimer – The display module used in this article is a promotional consideration made available by Freetronics.

Posted via email from tronixstuff's posterous

Review – Digilent chipKIT Uno32

2012-01-28T20:24:00.001-08:00

In this review we consider a Digilent chipKIT Uno32 development board made available by element-14.

Introduction

This is a development board that is based on the Arduino Uno, however uses a Microchip PIC32MX320F128 microcontroller instead of the Atmel ATmega328 we are used to:

Digilent’s decision to use the PIC32 introduces some interesting changes to the Uno format, and the largest change to take note of is the clock speed – 80 MHz instead of the Uno’s 16 MHz. That certainly took my attention, and we can see this demonstrated shortly.

When shipped the board arrives alone in a cardboard box, without a USB cable:

All documentation is found on the Digilent website. There is also a support forum to discuss libraries, IDE updates and so on. The board itself is quite familiar upon initial inspection:

You can see that Arduino shield will physically fit onto the board, and the extra I/O pins are accessed through the second rows of jumpers inside the board. With some crafty PCB creation skills you could make your own Uno32 shields, or consider one of the boards available from element-14 or Digilent.

As for the other specifications of the Uno32:

Clock speed – 80 MHz
128K flash program memory
16K SRAM data memory
I/O pins – 42 (12 used as analogue inputs or digital I/O)
Five PWM pins
FTDI chip for USB interface
Two user LEDs
Same form factor as Arduino Uno boards, which allows physical shield compatibility
Five interrupt pins
On board real-time clock (external crystal required)

You will need a new IDE, and you can download Uno32-modified versions of the Arduino v22 and v23 IDE from here for Windows, MacOS and 32-bit Linux (no 64-bit…). The bootloader is preinstalled on the Uno32 and after installing the special IDE it works just as our normal Arduinos do in terms of editing and uploading sketches. The board also is compatible with the Microchip MPLAB IDE and PICkit3 in-circuit debugger if you want to use the Uno32 as a normal PIC32 development board. There is a row of holes between the USB socket and the DC socket that will need header pins soldered in for PICkit3 use.

Speed comparison

Naturally you want to see the speed test. The following sketch was run on an Arduino Uno and the Uno32 boards using IDE v1.0 for the Uno and the MPIDE v23 for the Uno32:

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

unsigned long a,b,c,d,e;

void loop() { a=millis(); for (c=1; c<1000000; c++) { d=sq(c); } b=millis(); e=b-a; Serial.print("Duration: "); Serial.print(e); Serial.println("ms"); do {} while (1>0); }

And here are the results of running the sketch four times on each board (click image to enlarge):

Well that’s pretty impressive – over sixty times faster than the Arduino Uno. Therein lies the major reason to use this board over the Uno. The eagle-eyed among you may have also noticed the difference in the compiled binary sketch size – 6432 bytes for the Uno32 vs. 2540 bytes for the Arduino Uno. That’s interesting.

Nevertheless there are many things to take note of when moving from Arduino to Uno32, or in other words – you can’t just swap out an Arduino Uno for an Uno32, recompile and run your sketch at the faster speed. The Microchip PIC32 is very much a different beast to the Atmel AVRs we’re used to, so it is important that you understand the differences in hardware and software to take advantage of the Uno32. So let’s run through those now.

Power Differences

The Uno32 is a 3.3V board due to the PIC32. You can still power it via USB, or connect between 7~15 VDC to the power socket on the board. You can change a jumper and feed 5V directly into the board bypassing the 5V regulator. External power is regulated to 5V then to 3.3V. From a total of 1A current, the PIC32 uses 75mA, so you can draw up to 925mA from the 5V bus or 425mA from the 3.3V bus (or a mixture from both). It would pay to determine your current load before testing to avoid damaging the board, however the manual notes that the regulators will become hot at high current loads but do have thermal protection. Finally there is also a jumper that chooses between a 5V or 3.3V voltage feed to the shields. As always, consult themanual first.

I/O Differences

Although the PIC32 being a 3.3V part, the manual states that the digital I/O pins are 5V tolerant, so applying 5V to a digital input won’t damage the PIC32. Logic on the other hand is a different kettle of fish. According to the manual a digital ‘high’ when sourcing 12mA of current will only reach close to 3.3V. This may be too low in some situations so check your threshold voltages when choosing external parts. Furthermore, the analogue reference voltage (AREF) is restricted to 3.3V.

One stand-out difference is that you can only source 18mA from a digital pin, which is OK if you’re blinking some LEDs. However for logic output to keep the voltage range below 0.4V for ‘low’ and above 2.4V for ‘high’ the current must be restricted to -12~+7mA – another different limitaion. Finally, the maximum current you can source over all the I/O pins at once is 200mA.

There are two UARTs, number one where we expect it (D0/D1) and another on pins 39 and 40. I2C is on A4/A5 but needs to be activated with a jumper. Note that unlike an Arduino there aren’t any inbuilt pull-up resistors for the I2C bus, so add your own. There is also an SPI bus at the usual position (D10~13) and interestingly you can change the board between SPI master and slave via another set of jumpers. There are five pulse-width modulation outputs, however one is on D10 which is also part of the SPI bus. Finally there are five hardware interrupt pins.

Question – What type of processor core does the PIC32 use?

Shield Compatibility

Arduino shields will physically fit onto the Uno32 – but you need to be aware of the I/O differences listed above, the voltage and current specification and also the software side of things. Again – do your research before making the commitment to the hardware.

Software Compatibility

The Uno32 is compatible with a variety of Arduino sketches, but not all. This in a large part is due to the libraries which will need to be sourced from the community or rewritten yourself if not provided with the MPIDE software. There is a community on the support forum which is contributing their own, such as the real-time clock library – but again, research needs to be done before use. When trying to use an existing Arduino sketch and hardware, you will need to spend some time checking for compatibility. Again – it’s much easier to design a new project around the Uno32 than rejig an existing one.

Open Source?

One of the things many people love about the Arduino ecosystem is that the entire system is open source hardware and software. Without causing a pro/con argument about software licensing you should note that not all of the software toolchain for the Uno32 is open, nor the USB or TCP/IP stack. There is some interesting discourse about this here.

Conclusion

A lot of work needs to be done to ensure compatibility with existing Arduino applications. The Uno32 is tempting due to the raw clock-speed increase, however the sketch/library and hardware differences may introduce a few road blocks. However, when designing a project from scratch and understand the licensing limitations, the Uno32 would be great as you know what you have to work with – a much faster board with much more I/O. And it is very inexpensive, less than ~$35.

Finally, if you’re looking for a very inexpensive PIC32 development board to use with Microchip MPLAB, the Uno32 is a great deal that can possibly interface with a wide variety of shields from the Arduino world.

Disclaimer – The Chipkit Uno32 board reviewed in this article was a promotional consideration made available by element-14.

Posted via email from tronixstuff's posterous

Arduino meets Las Vegas with the Freetronics DMD

2012-01-23T05:50:00.001-08:00

Hello Readers

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

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

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

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

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

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

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

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

Here is a quick video of our example sketch:

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

dmd.clearScreen( true );

to turn off all the pixels, or

dmd.clearScreen( true );

to turn on all the pixels.

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

Question – How many LEDs are contained in the Freetronics DMD?

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

dmd.selectFont(System5x7);

for a smaller font or

dmd.selectFont(Arial_Black_16);

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

dmd.drawChar(  x,  y, 'x', GRAPHICS_NORMAL );

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

dmd.drawChar(  10,  5, 'A', GRAPHICS_NORMAL );

results with:

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

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

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

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

dmd.drawString( 0,0, "Hello,", 5, GRAPHICS_NORMAL ); dmd.drawString( 2,9, "world,", 5, GRAPHICS_NORMAL );

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

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

dmd.writePixel(  x,y, GRAPHICS_NORMAL,1); // turn on a pixel at location x,y

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

   dmd.drawCircle( x,  y,  r, GRAPHICS_NORMAL );

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

   dmd.drawLine(  x1, y1, x2, y2, GRAPHICS_NORMAL );

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

dmd.drawBox(x1, y1, x2, y2, GRAPHICS_NORMAL );

And to draw a filled rectangle use:

dmd.drawFilledBox(x1, y1, x2, y2, GRAPHICS_NORMAL );

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

So there you have it, an inexpensive and easy to use display board with all sorts of applications. Although the demonstrations contained within this article were rather simple, you now have the knowledge to apply your imagination to the DMD and display what you like. For more information, support and conversation visit the Freetronics product page and support forum.

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

Posted via email from tronixstuff's posterous

Review: Mayhew Labs “Go Between” Arduino Shield

2012-01-17T05:05:00.001-08:00

Hello readers

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

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

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

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

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

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

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

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

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

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

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

[Note - the "Go Between" Shield was purchased by myself personally and reviewed without notifying the manufacturer or retailer]

Posted via email from tronixstuff's posterous

Initial Review: Akafuino-X Microcontroller Board

2012-01-15T03:20:00.001-08:00

Hello Readers

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

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

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

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

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

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

Other changes include:

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

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

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

// Arduino Uno test // void setup() { Serial.begin(9600); }

unsigned long a,b,c,d,e;

void loop() { a=millis(); for (c=1; c<1000000; c++) { d=sq(c); } b=millis(); e=b-a; Serial.print("Duration: "); Serial.print(e); Serial.println("ms"); do {} while (1>0); }

And here are the results of running the sketch four times on each board (click image to enlarge):

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

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

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

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

Posted via email from tronixstuff's posterous

December 2011 Competition Results

2012-01-07T21:52:00.001-08:00

Hello readers

Well December has well and truly passed on so it is time to announce the winners of our December 2011 competition. The lucky winner of the first prize, which consists of the eleven modules from the new Freetronics Module/Sensor range, as reviewed recently:

Is Stephanie F. from Melbourne, Australia. I hope you enjoy working with the new modules.

And the lucky winner of the second prize, the awesome and still the world’s best all-in-one Arduino Uno/ethernet/PoE/uSD card board solution – the Freetronics EtherTen:

Is Jaroslav F. from Slovakia. Your EtherTen will be on the way around the globe shortly. In the meanwhile thanks to everyone for taking the effort to enter our competition and having some fun. As always we had a few ineligible entries and a few rude ones. Why? I don’t know.

And of course thanks to our sponsor Freetronics! Stay tuned for the January competition which will be announced shortly. In the meanwhile I’d better get back to work and write something…

So 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.

Posted via email from tronixstuff's posterous

Welcome to “Silicon Chip” Magazine readers

2011-12-26T20:25:00.001-08:00

Hello readers

Published in the January 2012 issue of “Silicon Chip” magazine is an eight page feature article by Jonathan Oxer introducing the Arduino system and how the hardware and software work together to allow anyone to turn their technological ideas into reality. If you have read Jon’s article and were directed here – thanks for visiting! We have much more content than just Arduino tutorials, however to get started with them please click here or select from one of the chapters listed in the “Arduino Tutorials” section on the right-hand side of this web page. Our site is a work in progress and if you have any feedback or questions please email john at tronixstuff dot com, or visit our moderated Google Group.

Be sure to take advantage of the discount code on page seventeen made available by Little Bird Electronics - Australia’s largest Arduino and related electronics distributor; and also check out the range of Arduino-compatible equipment atFreetronics.

For those not familiar with the magazine, here is the cover for the January 2012 issue:

So what is “Silicon Chip” magazine all about? It is Australia’s window to the wide world of electronics, backed by a team of engineers and enthusiasts with decades of experience and knowledge. Each month you can read about in-house projects by the team and also submitted by readers – covering basic circuits right through to digital and computer systems, quality hi-fi and audio projects, news, reviews, readers’ letters, the humorous columns and a wide variety of kits to assemble. There is also a wide range of advertising from related businesses that helps you find new products and suppliers that you may not have known about.

Silicon Chip is the only Australian electronics magazine and one of the few left in the world with a broad appeal to the beginner and expert alike, and the projects described are always good value and not priced or designed out of most peoples’ reach. I unashamedly recommend you pick up a copy from the newsagent or take out a subscription if possible, it’s a great read and there’s always lots to learn and laugh about.

In the meanwhile, here’s the last question for our monthly competition:

Question: Who is the editor of “Silicon Chip” magazine?

Finally, that’s it for 2011. A big thank you to all of our readers for your visits, feedback, compliments, criticism, donations, and the crazy emails received through the year. And of course to all the great suppliers who help out with promotional considerations and sponsor our monthly competitions. Keeping this site together has been interesting, educational and a whole lot of fun, and I hope you think so too. There is a lot coming up for 2012 – so stay tuned via twitter, Google+, or subscribe by email or RSS on the right-hand side of this page.

Have fun and Happy New Year

Posted via email from tronixstuff's posterous

Clock Kit Round-up – December 2011

2011-12-22T08:28:00.001-08:00

Hello Readers

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

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

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

adafruit industries “ice tube” clock

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

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

nootropic design Defusable Clock Kit

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

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

ogilumen nixie tube kits

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

Alan Parekh’s Multimeter Clock Kit

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

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

akafugu VFD Modular Clock

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

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

tubeclock.com kits

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

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

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

evil mad science clocks

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

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

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

Question: Which Soviet leader allegedly banged his shoe in the United Nations?

Kabtronics Clock Kits

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

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

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

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

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

The GPS FLW Display Clock

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

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

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

adafruit industries monochron®

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

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

Spikenzie Labs Solder : Time™ watch kit

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

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

Velleman Kits

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

… the 2¼” 7-Segment Digital Clock:

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

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

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

Nocrotec Nixie Clocks

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

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

nixiekits.eu

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

… or this funky number:

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

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

Minty Time

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

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

The Chronulator

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

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

Denkimono

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

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

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

Posted via email from tronixstuff's posterous

Review – nootropic design defusable clock kit

2011-12-21T02:43:00.001-08:00

Hello Readers

In this review we examine an interesting, fun and possibly a prankster’s delight – the “Defusable Clock Kit” fromnootropic design. The purpose of this kit is to construct a clock that counts down in a similar method to “movie-style” bombs, and it has terminals to connect four wires to the board. When the countdown timer is beeping away, you need to choose which wire to cut otherwise the “bomb” (alarm) goes off.

Furthermore, it also functions as a normal clock with an alarm, so you can use it daily normal activities. And finally it is based on the Arduino system which allows the kit to be reprogrammed at a later date. Now let’s move forward by examining kit construction.

Packaging

The kit arrives in a re-sealable antistatic pouch that can be reused without any effort:

Assembly

Detailed instructions can be found on the product website. The kit has a very clear and well-detailed silk screen on the PCB:

All the parts required are included, as well as an IC socket for the microcontroller:

However it looks like someone in the kitting department was in a hurry, things like this are pretty inexcusable – but recoverable:

Nothing that can’t be fixed carefully with some needle-nose pliers, nevertheless it was somewhat inconvenient. Some beginners may not have the patience or finesse to fix this themselves, and end up with a useless microcontroller. Moving forward, the first parts to solder in are the resistors:

… then to the other lower-profile components:

… and the rest:

Which leaves us with the final product:

The clock is designed around simple Arduino-compatible circuitry, so if you wish to alter the firware for the clock or upload your own sketch, you will need to fit the six-way header pins (in order to connect a USB-FTDI cable). As the pins are horizontal and tend to fall over, it’s easier to solder the first pin from the top of the PCB to hold it in place:

… then turn the PCB over and solder the rest.

Operation

Power is supplied via the DC socket on the PCB, and converted to 5V with a typical 7805 regulator. Therefore your input voltage can range between normal levels of 9~12VDC. Once the power is connected you can set the time for the clock and alarm for normal use. However if you feel like some sweat-inducing excitement, connect four wires each between the terminal blocks at the top of the PCB. Then press the red button to start the ten-second countdown. You can also increase or decrease the countdown time.

Your chances of defusing it in time can be quite low – by cutting one wire you can defuse it, by cutting two other wires nothing will happen and the clock keeps ticking – and by cutting the final wire… well, it’s all over. The wires are randomly chosen each time so you can’t predict which will be the correct wire. (Unless you change the firmware). Now let’s see the clock in action:

At this juncture it would be appropriate to warn the users of this kit not to … well, misuse the clock. To be honest I’m surprised such a kit originated from the US in the first place, but then again it never hurts to have a sense of humour. But seriously, to the untrained eye or casual security guard – this kit will look pretty damn real. So no making any mock explosive models with Play-Doh or metal cylinders and leaving them on the train or bus or under someone’s toilet seat. Then again, that would be good for a laugh – so please keep it at home, not in the railway station.

Question – Who played alongside with Mel Gibson in the “Lethal Weapon” movies?

Further expansion

As mentioned earlier this kit is Arduino (Duemilanove) compatible, you can upload new sketches using a 5V FTDI cable or swapping the microcontroller over in another Arduino-style board. You have four LEDs, a 4-digit 7-segment LED module, a buzzer, and four digital I/O pins via the terminal block on the top-right of the PCB which could control external devices. Furthermore you can download and examine the clock sketch to modify or deconstruct it to determine the operation.

Conclusion

Apart from the laughs and possible mayhem you could cause with this, the kit is easy to assemble and works as described. It would make a great present to get someone interested in electronics, or help them with soldering practice. Furthermore it is certainly unique, and would be fun at parties and other events.

This kit and many other electronic goodies are available from Little Bird Electronics. High-resolution images available on flickr.

Posted via email from tronixstuff's posterous

Review – Akafugu TWI 7-Segment Display

2011-12-13T22:51:00.001-08:00

Hello Readers

Today we review a product from a new company based in Japan – akafugu. From their website:

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

And with this in mind we examine their TWI 7-segment display board. It consists of a four digit, seven-segment LED module driven by an Atmel ATtiny microcontroller – and has an I2C (or called TWI for “two-wire interface”) interface. By using I2C you only need power, GND, SDA and CLK lines – which saves on I/O and physical space.

Packaging

The display arrives appropriately packaged in reusable bags, and the main board is sealed in an anti-static pouch:

Assembly

The display board arrives partly-assembled. The MCU is presoldered to the board, so all we need to solder are the external connections on each side of the board, and the LED module. It is quite small and of an excellent quality:

The reason for having the power and data lines on both side is that you can then daisy-chain the displays. Speaking of which, the review unit arrived with a common-anode white LED module (data sheet.pdf) – however you can also order it in red or blue. Although they are not included, I soldered in a line of socket pins to allow for changing the LED module later on:

The final product is neat and compact, the view from the rear:

Note the ISP header pin sockets which allow low-level programming of the ATtiny4313 MCU. And the front:

akafugu also sell an optional housing stand, manufactured from transparent acrylic, which turns the display module into a nice little desk stand model:

Using the display module

Now to put the display to use. As it is controlled via I2C/TWI a variety of microcontroller platforms will be able to use the display. For our examples we will be using an Arduino-compatible board. Before moving forward you need to download and install the Arduino library which is available (as well as an avr-gcc library) on Github. Note that the example sketches in the Arduino library are for IDE v1.0.

As the module uses its own microcontroller, you can change the I2C bus address with a simple sketch (which is provided with the library). This is a great idea, which removes any chance of clashing with other bus devices, and allows more modules to be on the same bus. The default address is 0X12h.

When using the module, the following lines need to be in your sketch:

#include #include <TWIDisplay.h> #define SLAVE_ADDR 0x12 TWIDisplay disp(0x12);

void setup() { Wire.begin(); disp.setRotateMode(); disp.clear(); disp.setBrightness(255); }

You can change the brightness mid-sketch using disp.setBrightness() with a parameter between zero and 255. To display an integer, use:

  disp.writeInt(8888); // displays '8888'

To turn on or off the decimal points, use:

  disp.setDot(x,boolean); // where x is the digit (0~3 from left to right) and boolean is true for on, false for off

To clear the display, use:

 disp.clear();

You can even display strings of text. Not every character can be displayed, however most can and the effect of scrolling looks good. For some example code:

char message[] = "This is a long message "; for (int i = 0; i < strlen(message); i++) { disp.print(message[i]); delay(250);

Now to put the display to work! Using this IDE v1.0 demonstration sketch (download), we have created the following display:

For the curious, the current drawn with all segments on at full brightness is just over 33 milliamps:

Conclusion

When you need to display some numerical or other fitting data with a greater clarity than an LCD, or just love LEDs then you could do very well with this display. The designers have made a quality board and backed it up with documentation and (unlike many much larger, more prominent companies) a mature library to ensure it works first time. Furthermore the use of the I2C/TWI bus removes the problem of wasting digital output pins on your MCU – and the ability to change the bus address is perfect. So give akafugu a go and you will not be disappointed. The display and other goodies are available directly from akafugu.jp.

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

Posted via email from tronixstuff's posterous

Project – Ultrasonic Combination Switch

2011-12-12T18:35:00.001-08:00

Hello Readers

Time for a follow-up to the Single Button Combination Lock by creating another oddball type of switch/lock. To activate this switch we make use of a Parallax Ping))) Ultrasonic sensor, an Arduino-style board and some other hardware – to make a device that receives a four-number code which is made up of the distance between a hand and the sensor. If Arduino and ultrasonic sensors are new to you, please read this tutorial before moving on.

The required hardware for this project is minimal and shown below – a Freetronics Arduino-compatible board, thePing))) sensor, and for display purposes we have an I2C-interface LCD module:

The combination for our ‘lock’ will consist of four integers. Each integer is the distance measured between the sensor and the user’s hand (etc.). For example, a combination may be 20, 15, 20, 15. So for the switch to be activated the user must place their hand 20cm away, then 15, then 20, then 15cm away. Our switch will have a delay between each measurement which can be modified in the sketch.

To keep things simple the overlord of the switch must insert the PIN into the switch sketch. Therefore we need a way to take measurements to generate a PIN. We do this with the following sketch, it simply displays the distance on the LCD (download sketch):

// Ultrasonic combination lock - distance display // John Boxall - December 2011 // tronixstuff.wordpress.com/projects | CC by-sa-nc

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

int signal=8;

void setup() { pinMode(signal, OUTPUT); lcd.init(); // initialize the lcd lcd.backlight(); // turn on LCD backlight }

int getDistance() // returns distance from Ping))) sensor in cm { int distance; unsigned long pulseduration=0; // get the raw measurement data from Ping))) // set pin as output so we can send a pulse pinMode(signal, OUTPUT); // set output to LOW digitalWrite(signal, LOW); delayMicroseconds(5); // now send the 5uS pulse out to activate Ping))) digitalWrite(signal, HIGH); delayMicroseconds(5); digitalWrite(signal, LOW); // now we need to change the digital pin // to input to read the incoming pulse pinMode(signal, INPUT); // finally, measure the length of the incoming pulse pulseduration=pulseIn(signal, HIGH); // divide the pulse length by half pulseduration=pulseduration/2; // now convert to centimetres. We're metric here people... distance = int(pulseduration/29); return distance; }

void loop() { lcd.print(getDistance()); lcd.println(" cm "); delay(500); lcd.clear(); }

And here is a demonstration of the sketch in action:

Now for the switch itself. For our example the process of “unlocking” will be started by the user placing their hand at a distance of 10cm or less in front of the sensor. Doing so will trigger the function checkPIN(), where the display prompts the user for four “numbers” which are returned by placing their hand a certain distance away from the sensor four times, with a delay between each reading which is set by the variable adel. The values of the user’s distances are stored in the array attempt[4].

Question - What is an ultrasonic sound?

Once the four readings have been taken, they are compared against the values in the array PIN[]. Some tolerance has been built into the checking process, where the value entered can vary +/- a certain distance. This tolerance distance is stored in the variable t in this function. Each of the user’s entries are compared and the tolerance taken into account. If each entry is successful, one is added to the variable accept. If all entries are correct, accept will equal four – at which point the sketch will either “unlock” or display “*** DENIED ***” on the LCD.

Again, this is an example and you can modify the display or checking procedure yourself. Moving forward, here is our lock sketch (download):

// Ultrasonic combination lock // John Boxall - December 2011 // tronixstuff.wordpress.com/projects | CC by-sa-nc

int pin[]={ 20, 15, 20, 25}; // this is the "PIN" distances in cm

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

int signal=8; // digital pin for Ping))) signal

void setup() { pinMode(signal, OUTPUT); lcd.init(); // initialize the lcd lcd.backlight(); // turn on LCD backlight Serial.begin(9600); // for debug }

int getDistance() // returns distance from Ping))) sensor in cm { int distance; unsigned long pulseduration=0; // get the raw measurement data from Ping))) // set pin as output so we can send a pulse pinMode(signal, OUTPUT); // set output to LOW digitalWrite(signal, LOW); delayMicroseconds(5); // now send the 5uS pulse out to activate Ping))) digitalWrite(signal, HIGH); delayMicroseconds(5); digitalWrite(signal, LOW); // now we need to change the digital pin // to input to read the incoming pulse pinMode(signal, INPUT); // finally, measure the length of the incoming pulse pulseduration=pulseIn(signal, HIGH); // divide the pulse length by half pulseduration=pulseduration/2; // now convert to centimetres. We're metric here people... distance = int(pulseduration/29); return distance; }

void checkPIN() { int attempt[4]; // stores user's attempt values int accept=0; // used for checking resulting user entry int t=5; // +/- tolerance int adel=1500; // delay between movement attempts lcd.setCursor(0,0); lcd.print("Get ready... "); delay(adel); // delay before first distance measurement lcd.setCursor(0,0); lcd.print(" Position One "); lcd.setCursor(0,1); lcd.print(">>>>____________"); attempt[0]=getDistance(); delay(adel); lcd.setCursor(0,0); lcd.print(" Position Two "); lcd.setCursor(0,1); lcd.print(">>>>>>>>________"); attempt[1]=getDistance(); delay(adel); lcd.setCursor(0,0); lcd.print("Position Three "); lcd.setCursor(0,1); lcd.print(">>>>>>>>>>>>____"); attempt[2]=getDistance(); delay(adel); lcd.setCursor(0,0); lcd.print(" Position Four "); lcd.setCursor(0,1); lcd.print(">>>>>>>>>>>>>>>>"); attempt[3]=getDistance(); delay(adel); lcd.clear(); lcd.print("Checking ... "); // for visual effect more than anything delay(2000); lcd.clear();  // display user entry on serial monitor for debugging for (int z=0; z<4; z++) { Serial.println(attempt[z]); } Serial.println("------"); delay(2000);   // now compare against preset values // allow a +/- tolerance (tolerance in integer 't')  if (attempt[0]>=(pin[0]-t) && attempt[0]<=(pin[0]+t)) { accept++; } if (attempt[1]>=(pin[0]-t) && attempt[1]<=(pin[0]+t)) { accept++; } if (attempt[2]>=(pin[0]-t) && attempt[2]<=(pin[0]+t)) { accept++; } if (attempt[3]>=(pin[0]-t) && attempt[3]<=(pin[0]+t)) { accept++; }

if (accept==4) { // correct entry lcd.setCursor(0,0); lcd.print(" ** Accepted ** "); // here you would enter code to run when the switch was successfully activated delay(2000); } else if (accept!=4) { // incorrect entry lcd.setCursor(0,0); lcd.print(" *** DENIED *** "); // here you would enter code to run when the switch was unsuccessfully activated delay(2000); } }

void loop() { if (getDistance()<10) { lcd.clear(); checkPIN(); } lcd.setCursor(0,0); lcd.print(" ** Ready ** "); }

To finish the switch, a housing of some sort is required. adafruit industries sell a housing which has mounts for an Arduino-form board and 16×2 LCD which is convenient, so we use it for the finished example as shown below:

And for the final demonstration of the switch in action. Note that the delays between actions have been added for visual effect – you can always change them to suit yourself:

So there you have it – the base example for a different type of combination switch. I hope someone out there found this interesting or slightly useful

Posted via email from tronixstuff's posterous

Initial Review – Arduino v1.0 IDE

2011-12-09T05:19:00.001-08:00

Hello Readers

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

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

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

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

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

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

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

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

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

[core / libraries]  * Serial transmission is now asynchronous - that is, calls to Serial.print(), etc. add data to an outgoing buffer which is transmitted in the background. Also, the Serial.flush() command has been repurposed to wait for outgoing data to be transmitted, rather than dropping received incoming data.  * The behavior of Serial.print() on a byte has been changed to align it with the other numeric data types. In particular, it will now print the digits of its argument as separate ASCII digits (e.g. '1', '2', '3') rather than a single byte. The BYTE keyword has been removed. To send a single byte of data, use Serial.write() (which is present in Arduino 0022 as well).

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

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

byte a=0;

void loop() { for (a=38; a<48; a++) { Serial.print(a); Serial.print(" "); } do {} while (1>0); }

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

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

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

* The Serial class (as well as other classes inheriting from Stream, like EthernetClient, SoftwareSerial, Wire and more) now contains functions for parsing incoming data, based on the TextFinder library by Michael Margolis. They include find() and findUntil() to search for data, parseInt() and parseFloat() for converting incoming characters into numeric values, and readBytes() and readBytesUntil() for reading multiple bytes into a buffer. They use a timeout that can be set with the new setTimeout().

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

* The SoftwareSerial class has been reimplemented, using the code originally written for the NewSoftSerial library by Mikal Hart. This allows for multiple simultaneous instances, although only one can receive at a time.

One less library to worry about…

* Support has been added for printing strings stored in flash (program memory) rather than RAM. Wrap double-quoted strings in F() to indicate that they should be stored in flash, e.g. Serial.print(F("hello world")).

This should help us use memory more efficiently…

* The String class has been reimplemented as well, by Paul Stoffregen. This new version is more memory-efficient and robust. Some functions which previously returned new string instances (e.g. trim() and toUpperCase()) have been changed to instead modify strings in place.  * Support for DHCP and DNS has been added to the Ethernet library, thanks to integration by Adrian McEwen. Most classes in the Ethernet library have been renamed to add a "Ethernet" prefix and avoid conflicts with other networking libraries. In particular, "Client" is now "EthernetClient", "Server" is "EthernetServer", and "UDP" is "EthernetUDP". A new IPAddress class makes it easier to manipulate those values.

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

* The UDP API has been changed to be more similar to other libraries. Outgoing packets are now constructed using calls to the standard write(), print(), and println() functions – bracketed by beginPacket() and endPacket(). The parsePacket() function checks for and parses an incoming packet, which can then be read using available(), read(), and peek(). The remoteIP() and remotePort() functions provide information about the packet’s origin. (Again, thanks to Adrian McEwen for the implementation.)  * The Wire library has also been modified to use the standard read() and write() functions instead of send() and receive(). You can also use print() and println() for outgoing data.

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

* The SD library now supports multiple simultaneous open files. It also provides the isDirectory(), openNextFile(), and rewindDirectory() functions for iterating through all the files in a directory. (Thanks to Limor Fried.)

Well this is a win, now multiple forms of data can be logged into separate files.

As mentioned at the start, this is an initial review and by all means not complete. Feel free to leave your comments or notes for others to review as well, and as always if you find any errors please let us know.

For now the new IDE is a juncture in the Arduino evolution that is welcome. For new sketches and development in general there wouldn’t be any reason not to use it, and you can happily run several versions of the IDE on a single computer. However at this time there wouldn’t be any reason not to convert older sketches to the new v1.0 standard.

Question – What does the acronym ASCII mean?

Posted via email from tronixstuff's posterous

December 2011 Competition

2011-12-07T05:05:00.001-08:00

Hello Readers

It’s that time of the year again so we are running another competition. First let’s look at the prizes, then review the rules of entry.

— *** Prize One *** —

Prize One consists of the eleven modules from the new Freetronics Module/Sensor range, as reviewed recently:

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

— *** Prize Two*** —

Prize Two consists of one Freetronics EtherTen:

This is the mother of all Arduino-compatible boards. Designed in Australia and manufactured to the highest quality standards the EtherTen replaces three boards – consider having an Arduino Uno SMD, Ethernet shield with PoE, and a microSD shield – all on the one board. From the Freetronics website:

The EtherTen is a 100% Arduino compatible board that can talk to the world. Do Twitter updates automatically, serve web pages, connect to web services, display sensor data online, and control devices using a web browser. The Freetronics EtherTen uses the same ATmega328P as the Duemilanove and the same Wiznet W5100 chip used by the official Arduino Ethernet Shield, so it’s 100% compatible with the Ethernet library and sketches. Any project you would previously have built with an Arduino and an Ethernet shield stacked together, you can now do all in a single, integrated board.

We’ve even added a micro SD card slot so you can store web content on the card, or log data to it.

All the good things about the Eleven and the Ethernet Shield have been combined into this one device so please see those pages for all the specific details, but the highlights include:

Gold-plated PCB.

Top and bottom parts overlays.

Top-spec ATmega328P MCU.

Mini-USB connector: no more shorts against shields!

D13 pin isolated with a MOSFET so you can use it as an input.

Power-over-Ethernet support, both cheapie DIY or full 802.3af standards-compliant.

Ethernet activity indicators on the PCB and the jack.

10/100base-T auto-selection.

Fully compatible with standard Ethernet library.

Reset management chip.

Fixed SPI behavior on Ethernet chipset.

Robust power filtering.

Sexy rounded corners.

Note that just like our Ethernet Shield with PoE support, the EtherTen provides a number of options for different Power over Ethernet. You can use the supplied jumpers and feed 7-12Vdc down the wire for cheap DIY version, or you can fit our PoE Regulator 24V and feed a bit more voltage down the wire, or you can use our PoE Regulator 802.3AF along with a proper commercial PoE injector or switch. It’s up to you. Available fromFreetronics or a reseller near you.

— *** How to Enter *** —

There will be six questions for you to answer spread across articles published in December. At the end of December and once you have answers to all six, email the answers along with your full name, email address and postal address to competition at tronixstuff dot com with the subject heading December. During the second week of January, all the correct entries will be collated and two randomly chosen. The first correct entry drawn will receive prize one, the second correct entry drawn receives prize two. Entries will be accepted until 05/01/2012 0005h GMT.

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

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

Posted via email from tronixstuff's posterous

Review – Freetronics Module Family

2011-12-05T06:26:00.001-08:00

Hello

In this article we examine a new range of eleven electronic modules from Freetronics. When experimenting with electronics or working on a prototype of a design, the use of electronic components in module form can make construction easier, and also reduce the time between thoughts and actually making something So let’s have a look at each module in more detail…

PoE Power Regulator – 28V

This is a tiny switchmode voltage regulator with two uses – the first being regulation of higher voltage up to 28V carried via an Ethernet cable to a Freetronics Ethernet shield or EtherTen to power the board itself. The PCB is designed to drop into the shield or EtherTen as such:

… and converts the incoming voltage down to 7V which can be regulated by the EtherTen’s inbuilt regulator. The second use of this board is a very handy power supply for breadboarding or other experimentation. By bridging the solder pads on the rear of the board, the output is set to 5V DC, as such:

Note the addition of the header pins, which make insertion into a breadboard very easy – so now you have a 5V 1A DC power supply. For more information visit the product page.

N-MOSFET Driver/Output Module

This module contains an On Semi NTD5867NL MOSFET which allows the switching of a high current and voltage line – 60V at up to 20A – with a simple Arduino or other MCU digital output pin. The package is small and also contains enlarged holes for direct connection of high-current capability wire:

The onboard circuitry includes a pull-down resistor to ensure the MOSFET is off by default. For more information see theproduct page.

Logic Level Converter Module

This is a very simple and inexpensive method to interface 3.3V sensors to 5V microcontrollers in either direction.The module contains four independent channels, as shown in the image below:

However you can interface any low or higher voltage, as long as you connect the low and high voltages to the correct sides (marked on the PCB’s silk screen). For more information please visit the product page.

RGBLED Module

Surprisingly this module contains a RGB LED module (red, green and blue LEDs) which is controlled by a WS2801 constant-current LED driver IC. This module is only uses two digital output pins, and can be daisy-chained to control many modules with the same two pins. The connections are shown clearly on the module:

The WS2801 controller IC is on the rear:

There are several ways to control the LEDs. One way is using the sketch from the product home page, which results with the following demonstration output:

Or there is a unique Arduino WS2801 library available for download from here. Using the strandtest example included with the library results with the following:

During operation the module used less than 24 mA of current and therefore can happily run from a standard Arduino-type board without any issues. For more information please visit the product page.

TEMP Temperature Sensor Module

This module allows the simple measurement of temperature using the popular DS18B20 temperature sensor. You can measure temperatures between -55° and 125°C with an accuracy of +/- 0.5°C. Furthermore as the sensor uses the 1-wire bus, you can daisy-chain more than one sensor for multiple readings in the one application. The board is simple to use, and also contains a power-on LED:

Using the demonstation Arduino sketch from the product page results in the following output via the serial monitor:

Using this module is preferable to the popular Analog Devices TMP36, as it has an analogue output which can be interfered with, and requires an analogue input pin for each sensor, whereas this module has a digital output and as mentioned previously can be daisy-chained. For more information please visit the product page.

Humidity and Temperature Sensor Module

For the weather-measuring folk here is a module with temperatures and humidity. Using the popular DHT22 sensor module the temperature range is -4°C to +125°C with an accuracy of +/- 0.5°C, and humidity with an accuracy of between two and five percent. Only one digital input pin is required, and the board is clearly labelled:

There is also a blue power-on LED towards the top-right of the sensor. Using the module is quite simple with Arduino – download and use the example sketch included in the sensor library you can download from here. For the demonstration connect the centre data pin to Arduino digital two. Here is an example of the demonstration output:

Although the update speed is not lightning-fast, this should not be an issue unless you’re measuring real-time external temperature of your jet or rocket. For more information please see the product page.

Shift Register/Expansion Module

This board uses a 74HC595 serial-in parallel-out shift register which enables you to control eight digital outputs with only three digital pins, for example:

You can daisy-chain these modules to increase the number of digital outputs in multiples of eight, all while only using the three digital output pins on your Arduino or other microcontroller. For more information about how to use shift registers with Arduino systems, read our detailed tutorial. Otherwise for more information about the module please visit theproduct page.

Hall Effect Magnetic and Proximity Sensor Module

This module contains a sensor which changes output from HIGH to LOW when a magnetic presence is detected, for example a magnet. The board also has an LED which indicates the presence of the magnet to aid in troubleshooting:

Using this module and a small magnet would be an easy way to create a speedometer for a bicycle, the module is mounted to the fork, and the magnet on the rim of the front wheel. For more ideas consider the speedometer project in this tutorial. Otherwise for more information about this module please visit the product page.

Microphone Sound Input Module

This module performs two functions – it can return the sound pressure level (SPL) or the amplified audio waveform from the electret microphone. The LED (labelled “DETECT”) on the board visually displays an approximation of the SPL – for example:

… however the value can be returned by using an analogue input pin on an Arduino (etc). to return a numerical value. To do this connect the SPL pin to the analogue input. The MIC pin is used to take the amplified output from the microphone, to be processed by an ADC or used in an audio project. For more information please visit the product page.

Light Sensor Module

This module uses the TEMT6000 light sensor which returns more consistent values than can be possible using a light-dependent resistor. It outputs a voltage from the OUT pin that is proportional to the light level. The module is very small:

Use is simple – just measure the value returned from the OUT pin using an analogue input pin on your Arduino (etc). For more information please visit the product page. And finally, the:

Sound and Buzzer Module

This module contains a piezoelectric element that can be used to generate sounds (in the form of musical buzzes…):

Driving the buzzer is simple, just use pulse-width modulation. Arduino users can find a good demonstration of this here. Furthermore, as piezoelectric elements can also generate a small electrical current when vibrated, they can be used as “shock” detectors by measuring the voltage across the terminals of the element. The procedure to do this is also explained clearly here.

Now for a final demonstration – we use the light sensor to demonstrate making some noise with the buzzer module:

One final note I would like to make is that the design and construction quality of each module is first rate. The PCBs are strong, and the silk-screening is useful and descriptive. If you find the need for some or all of the functions made available in this range, you could do worse by not considering a Freetronics unit. Finally, although this has only been a short introduction to the modules for now, we will make use of them in later projects.

The modules are available directly from Freetronics or through their network of resellers.

Disclaimer – Modules reviewed in this article are a promotional consideration made available by Freetronics

Posted via email from tronixstuff's posterous

Tutorial – Parallax Ping))) Ultrasonic Sensor

2011-11-28T00:22:00.001-08:00

This is chapter forty-five (!) 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.

Welcome back

Whilst being a passenger in a vehicle with a ‘reversing sensors’, I became somewhat curious as to how the sensors operated and how we can make use of them. So for this chapter we will investigate an ultrasonic sensor from Parallax called the Ping)))™ Ultrasonic Distance Sensor. It can measure distances between ~2cm and ~3m in length. Here is our example sensor:

(Memories of Number Five …)

Parallax have done a lot of work, the board contains not just the bare sensor hardware but controller circuitry as well:

Which is great as it leaves us with only three pins – 5V, GND and signal. More on those in a moment, but first…

How does it work?

Good question. The unit sends out an ultrasonic (a sound that has a frequency which is higher than can be heard by the human ear) burst of sound from one transducer (the round silver things) and waits for it bounce off an object and return – which is detected by the other transducer. The board will then return to us the period of time taken for this process to take, which we can interpret to determine the distance between the sensor and the object from which the ultrasonic sound bounced from.

The Ping))) only measures a distance when requested – to do this we send a very short HIGH pulse of five microseconds to the signal pin. After a brief moment a pulse will come from the board on the same signal pin. The period of this second pulse is the amount of time the sound took to travel out and back from the sensor – so we divide it by two to calculate the distance. Finally, as the the speed of sound is 340 metres per second, the Arduino sketch can calculate the distance to whatever units required.

It may sound complex, but it is not – so let’s run through the theory of operation with an example. Using our digital storage oscillscope we have measured the waveforms on the signal pin during a typical measurement. Consider the following example of measuring a distance of 12cm (click image to enlarge):

You can see the 5uS pulse in the centre and the pulse returned from the sensor board on the right. Now to zoom in on the returned pulse (click image to enlarge):

Without being too picky the pulse is roughly 720uS (microseconds) long – the duration of ultrasonic sound’s return trip from the sensor board. So we divide this by two to find the time to travel the distance – 360uS. Recall the speed of sound is 340 metres per second – which converts to 29.412 uS per centimetre. So, 360uS divided by 29.412 uS gives 12.239902081… centimetres. Rounded that gives us 12 centimetres. Easy!

Finally, there are some limitations to using the Ping))) sensor. Download the data sheet (pdf) and read pages three to five for information on how to effectively mount the sensor and the sensitivity results from factory resting.

How do we use it with Arduino

As described previously we first need to send a 5uS pulse, then listen for the return pulse. The following sketch does just that, then converts the data to centimetres and displays the result on the serial monitor. The code has been commented to explain each step.

Example 45.1

// Example 45.1 - tronixstuff.wordpress.com - CC by-sa-nc // Connect Ping))) signal pin to Arduino digital 8

int signal=8; int distance; unsigned long pulseduration=0;

void setup() { pinMode(signal, OUTPUT); Serial.begin(9600); }

void measureDistance() { // set pin as output so we can send a pulse pinMode(signal, OUTPUT);

// set output to LOW digitalWrite(signal, LOW); delayMicroseconds(5);  // now send the 5uS pulse out to activate Ping))) digitalWrite(signal, HIGH); delayMicroseconds(5); digitalWrite(signal, LOW);  // now we need to change the digital pin // to input to read the incoming pulse pinMode(signal, INPUT);  // finally, measure the length of the incoming pulse pulseduration=pulseIn(signal, HIGH); }

void loop() { // get the raw measurement data from Ping))) measureDistance();  // divide the pulse length by half pulseduration=pulseduration/2;   // now convert to centimetres. We're metric here people... distance = int(pulseduration/29);  // Display on serial monitor Serial.print("Distance - "); Serial.print(distance); Serial.println(" cm"); delay(500); }

And the results of some hand-waving in the serial monitor:

So there you have it – you can now measure distance with a degree of accuracy. However that image above isn’t very exciting – instead let’s use a 7-segment display shield to get things up in lights. The shield uses the NXP SAA1064LED display driver IC (explained quite well here). You can download the demonstration sketch from here. And now for the video:

So there you have it – now the use of the sensor is up to your imagination. Stay tuned using the methods below to see what we get up to with this sensor in the future.

Posted via email from tronixstuff's posterous

Using an ATtiny as an Arduino

2011-11-22T06:07:00.001-08:00

Welcome back

In the last few weeks an article about how to use either an Atmel ATtiny45 or ATtiny85 microcontroller with Arduino software took my interest. The team at the High-Low Tech Group at MIT had 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. 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:

```
pinMode()
```
```
digitalWrite()
```
```
digitalRead()
```
```
analogRead()
```
```
analogWrite()
```
```
shiftOut()
```
```
pulseIn()
```
```
millis()
```
```
micros()
```
```
delay()
```
```
delayMicroseconds()
```

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

Getting Started

Hardware

The ATtiny needs to be wired up a certain way to allow the Arduino to act as a programmer.

For those with an Arduino Duemilanove/Freetronics TwentyTen (click schematic to enlarge):

For those with an Arduino Uno/Freetronics Eleven/EtherTen etc. (click schematic to enlarge):

Note the Uno version of the schematic has a 10uF electrolytic capacitor between Arduino RST and GND. Follow the schematics above each time you want to program the ATtiny. For more frequent use they would be an excellent candidate for a protoshield.

Software

From a software perspective, to use the ATtinys you need to add some files to your Arduino IDE. First, download this zip file. Create a folder called “hardware” in the the folder where you save your sketches. If you are unsure of this location, in the Arduino IDE select the File>Preferences option and you will see the following:

The top field “Sketchbook location:” will tell you where to put the files.

Next, extract the contents of the downloaded .zip file into the newly-created hardware folder. Finally, 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, create your sketch. 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

Before uploading your sketch – you need to select the correct board type. Select Tools>Board>ATtiny45 (or 85) (w/ Arduino as ISP). Then upload as normal. You will see an error message in the status window of the IDE as such:

The message is “normal” in this situation, so nothing to worry about.

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 method as described earlier. The matching circuit is:

Although it’s only a blinking LED, by making it work you have mastered the process. However, for the non-believers:

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 on delay(100); // wait for a second digitalWrite(0, LOW); // set the LED off digitalWrite(1, HIGH); // set the LED on delay(100); // 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.

Posted via email from tronixstuff's posterous

Tutorial: Arduino and Numeric Keypads – Part Two

2011-11-11T22:00:00.001-08:00

This is an addendum to chapter forty-two 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. Any files from tutorials will be found here.

Welcome back fellow arduidans!

This is the second part of our numeric keypad tutorial – in which we use the larger keypads with four rows of four buttons. For example:

Again, the keypad looks like a refugee from the 1980s – however it serves a purpose. Notice that there are eight connections at the bottom instead of seven – the extra connection is for the extra column of buttons – A~D. This example again came from Futurlec. For this tutorial you will need the data sheet for the pinouts, so download it from here (.pdf).

To use this keypad is very easy, if you haven’t already done so, download the numeric keypad Arduino library from here, copy the “Keypad” folder into your ../arduino-002x/libraries folder, then restart the Arduino IDE.

Now for our first example – just to check all is well. From a hardware perspective you will need:

An Arduino Uno or 100% compatible board
A 4×4 numeric keypad
An LCD of some sort. We will be using an I2C-interface model. If you are unsure about LCD usage, please see this tutorial
If you don’t have an LCD – that’s ok. Our demonstration sketch also sends the key presses to the serial monitor.

Connect the keypad to the Arduino in the following manner:

Keypad row 1 (pin eight) to Arduino digital 5
Keypad row 2 (pin 1) to Arduino digital 4
Keypad row 3 (pin 2) to Arduino digital 3
Keypad row 4 (pin 4) to Arduino digital 2
Keypad column 1 (pin 3) to Arduino digital 9
Keypad column 2 (pin 5) to Arduino digital 8
Keypad column 3 (pin 6) to Arduino digital 7
Keypad column 4 (pin 7) to Arduino digital 6

Now for the sketch – take note how we have accommodated for the larger numeric keypad:

the extra column in the array char keys[]
the extra pin in the array colPins[]
and the byte COLS = 4.

You can download the sketch from here.

Example 42.3

/* Example 42.3 - Numeric keypad and I2C LCD http://tronixstuff.wordpress.com/tutorials > chapter 42a Uses Keypad library for Arduino  http://www.arduino.cc/playground/Code/Keypad  by Mark Stanley, Alexander Brevig */  #include "Keypad.h" #include "Wire.h" // for I2C LCD #include "LiquidCrystal_I2C.h" // for I2C bus LCD module http://bit.ly/eNf7jM LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display  const byte ROWS = 4; //four rows const byte COLS = 4; //four columns char keys[ROWS][COLS] = {{'1','2','3','A'}, {'4','5','6','B'}, {'7','8','9','C'}, {'*','0','#','D'}}; byte rowPins[ROWS] = { 5, 4, 3, 2}; //connect to the row pinouts of the keypad byte colPins[COLS] = { 9, 8, 7, 6}; //connect to the column pinouts of the keypad int count=0;  Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );  void setup() { Serial.begin(9600); lcd.init();          // initialize the lcd lcd.backlight(); // turn on LCD backlight }  void loop() { char key = keypad.getKey(); if (key != NO_KEY) { lcd.print(key); Serial.print(key); count++; if (count==17) { lcd.clear(); count=0; } } }

And our action video:

Now for another example – we will repeat the keypad switch from chapter 42 – but allow the letters into the PIN, and use the LCD instead of LEDs for the status. In the following example, the PIN is 12AD56. Please remember that the functions correctPIN() and incorrectPIN() are example functions for resulting PIN entry – you would replace these with your own requirements, such as turning something on or off. You can download the sketch from here.

Example 42.4

// Example 42.4 - Six-character keypad switch // http://tronixstuff.wordpress.com/tutorials > chapter 42a  #include "Keypad.h" #include "Wire.h" // for I2C LCD #include "LiquidCrystal_I2C.h" // for I2C bus LCD module http://bit.ly/eNf7jM LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display  const byte ROWS = 4; //four rows const byte COLS = 4; //four columns char keys[ROWS][COLS] = {{'1','2','3','A'}, {'4','5','6','B'}, {'7','8','9','C'}, {'*','0','#','D'}}; byte rowPins[ROWS] = { 5, 4, 3, 2}; //connect to the row pinouts of the keypad byte colPins[COLS] = { 9, 8, 7, 6}; //connect to the column pinouts of the keypad  Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );  char PIN[6]={'1','2','A','D','5','6'}; // our secret (!) number char attempt[6]={ 0,0,0,0,0,0}; // used for comparison int z=0;  void setup() { lcd.init();          // initialize the lcd lcd.backlight(); // turn on LCD backlight lcd.print("  Enter PIN..."); }  void correctPIN() // do this if correct PIN entered { lcd.print("* Correct PIN *"); delay(1000); lcd.clear(); lcd.print("  Enter PIN..."); }  void incorrectPIN() // do this if incorrect PIN entered { lcd.print(" * Try again *"); delay(1000); lcd.clear(); lcd.print("  Enter PIN..."); }  void checkPIN() { int correct=0; for (int q=0; q<6; q++) { if (attempt[q]==PIN[q]) { correct++; } } if (correct==6) { correctPIN(); } else { incorrectPIN(); } for (int zz=0; zz<6; zz++) // wipe attempt { attempt[zz]=0; } }  void readKeypad() { char key = keypad.getKey(); if (key != NO_KEY) { switch(key) { case '*': z=0; break; case '#': delay(100); // for extra debounce lcd.clear(); checkPIN(); break; default: attempt[z]=key; z++; } } }  void loop() { readKeypad(); }

Now let’s see it in action:

So now you have the ability to use twelve and sixteen-button keypads with your Arduino systems.

Posted via email from tronixstuff's posterous

October 2011 Competition Results

2011-11-04T06:08:00.001-07:00

Hello readers

October has now passed by (too quickly!) and it is time to announce the winners of the October competition. Congratulations to all those who entered – there was some great examples of creativity and enthusiasm. Although less people entered this month, the standard of entries was very high – which made judging very difficult. However with some deliberation we narrowed it down to three entries:

First Prize:

Congratulations to Nick P from New York, USA for his entry:

Droid ‘bot assassin,
Misses elevated mark.
Forgot third axis.

Nick will receive a Freetronics USBDroid and one Terminal Shield:

Designed in Australia and manufactured to the highest quality standards the USBDroid combines the functionality of the Freetronics Eleven along with a USB host-mode controller and a microSD memory card slot all merged together into a single, integrated board that is 100% Arduino compatible. This is the ideal platform for developing peripherals or projects based around Android devices with ADK (Android Developer Kit) functionality, but without requiring a USB host controller shield stacked onto an Arduino. Connect your Android phone for all kinds of controller and networking features, and other USB devices like game controllers, Bluetooth dongles, digital cameras, etc. All the good things about the Eleven are included:

Gold-plated PCB.
Top and bottom parts overlays.
Top-spec ATmega328P MCU.
D13 pin isolated with a MOSFET so you can use it as an input.
Robust power filtering.
Sexy rounded corners.
PC communications with the Mini-USB connector: no more shorts against shields!
And of course the USB Host connector to go out to your Android phone and other USB devices.

In addition we’ve included a high current onboard power supply so you can charge your Android device directly off the USBDroid. Available now from a Freetronics reseller near you.

The Terminal Shield breaks out all the Arduino headers to handy screw terminals, making it really easy to connect external wires without using a soldering iron. Ideal for quick experiments or for robust connections! The center area of the shield is also a huge prototyping area, allowing you to add your own parts to suit your project. A blue “power” LED shows when your Arduino is powered up, and there are also red, green, and blue general-purpose LEDs with current-limiting resistors. The Terminal Shield comes with all the supporting components already fitted as surface-mount parts so you can start using it right away, and we even provide stackable headers to allow you to mount another shield on top.

Features

Gold-plated surface: solders easily and very resistant to finger oil, etc.
Large prototyping area with through-plated holes.
Clearly marked GND and 5V rails beside prototyping area.
Blue surface-mount “power on” LED.
2 × 100nF power supply smoothing capacitors pre-fitted as surface-mount parts.
Reset button wired through to the Arduino so you can reset it even with the shield mounted over the top.
3 general-purpose surface-mount LEDs (red, green, blue) with current limiting resistors pre-fitted: driveHIGH to illuminate.
Overlay printed on both the top and the bottom of the board so you don’t have to turn it over to see what you’re soldering onto.
Sexy rounded corners.

Second Prize:

Congratulations to James from Christchurch, New Zealand for his entry:

Ether Ten, what shall I make?
Why, remote access.
My home is automated.

James will receive a Freetronics EtherTen and the new AM3X 3-Axis Accelerometer Module:

The EtherTen is a 100% Arduino compatible board that can talk to the world. Do Twitter updates automatically, serve web pages, connect to web services, display sensor data online, and control devices using a web browser. The Freetronics EtherTen uses the same ATmega328P as the Duemilanove and the same Wiznet W5100 chip used by the official Arduino Ethernet Shield, so it’s 100% compatible with the Ethernet library and sketches. Any project you would previously have built with an Arduino and an Ethernet shield stacked together, you can now do all in a single, integrated board.

We’ve even added a micro SD card slot so you can store web content on the card, or log data to it.

All the good things about the Eleven and the Ethernet Shield have been combined into this one device so please see those pages for all the specific details, but the highlights include:

Gold-plated PCB.

Top and bottom parts overlays.

Top-spec ATmega328P MCU.

Mini-USB connector: no more shorts against shields!

D13 pin isolated with a MOSFET so you can use it as an input.

Power-over-Ethernet support, both cheapie DIY or full 802.3af standards-compliant.

Ethernet activity indicators on the PCB and the jack.

10/100base-T auto-selection.

Fully compatible with standard Ethernet library.

Reset management chip.

Fixed SPI behavior on Ethernet chipset.

Robust power filtering.

Sexy rounded corners.

Note that just like our Ethernet Shield with PoE support, the EtherTen provides a number of options for different Power over Ethernet. You can use the supplied jumpers and feed 7-12Vdc down the wire for cheap DIY version, or you can fit our PoE Regulator 24V and feed a bit more voltage down the wire, or you can use our PoE Regulator 802.3AF along with a proper commercial PoE injector or switch. It’s up to you.

Which way is up?

This tiny 3-axis accelerometer module can operate in either +/-1.5g or +/-6g ranges, giving your project the ability to tell which way is up. Ideal for robotics projects, tilt sensors, vehicle dataloggers, and whatever else you can dream up. It has independent X, Y, and Z axis outputs ready to connect directly to analog inputs on an Arduino, and we’ve included an onboard 3.3V regulator so that you can run it from either 5V or 3.3V. It even has a “zero g!” output to detect when the device is in free-fall, so you could connect that to an “interrupt” pin on an Arduino to have your project react immediately if it’s dropped!

Very cool.

The module includes mounting holes suitable for M3 or 1/8″ bolts, and a flat rear face so you can easily glue it to any surface. Available here now or at a Freetronics reseller near you.

Third Prize:

Congratulations to CV Rao from New Delhi, India for their entry:

I waiting to receive the Zoombadger,
To play with my daughter.
A game of detective and murderer,
Along with her lovely mother.

CV will receive three Snootlab Zombadge Kits:

With Trippy RGB sketch uploaded, this is the Snootlab games platform based on the Mitch Altman original design, it can receive original Snootlab collaborative games. This badge can be used for soldering workshop and electronic board programming. Being a badge, it can be worn as a pendant. More details on the dedicated website zombadge.com.

Once again thanks to everyone for their entries. We had a few ineligible entries and two rude ones. Such is the Internet!

And of course thanks to our sponsors Freetronics and Snootlab

Stay tuned for the November competition which will be announced shortly.

Posted via email from tronixstuff's posterous