Exploring the TI MSP430 platform with Energia Arduino-compatible IDE

Introduction

Over the last year or so Texas Instruments have been literally pushing their MSP430 development platform hard by offering an inexpensive development kit – their LaunchPad. For around ten dollars (not everyone could get it for $4.30) it includes a development board with flash emulation tool and USB interface, two of their microcontrollers, crystal, USB cable and some headers. It was (is?) a bargain and tens of thousands of LaunchPads were sold. Happy days.

However after the courier arrived and the parcel was opened, getting started with the LaunchPad was an issue for some people. Not everyone has been exposed to complex IDEs or university-level subjects on this topic. And to get started you needed to use a version of Code Composer Studio or IAR Embedded Workbench IDEs, which scared a few people off. So those LaunchPads went in the cupboard and gathered dust.

Well now it’s time to pull them out, as there’s a new way to program the MSP430 using a fork of the Arduino IDE – Energia. Put simply, it’s the Arduino IDE modified to compile and upload code to the LaunchPad, which makes this platform suddenly much more approachable.

Getting Started

You’ll need to download and install the appropriate USB drivers, then the IDE itself from here. To install the IDE you just download and extract it to your preferred location, in the same manner as the Arduino IDE. Then plug your LaunchPad into the USB. Finally,  load the IDE. Everything is familiar to the Arduino user, except the only surprise is the colour (red as a nod to TI perhaps…):

Looking good so far. All the menu options are familiar, the files have the .ino extension, and the preferences dialogue box is how we expect it. Don’t forget to select the correct port using the Tools > Serial port… menu. You will also need to select the type of MSP430 in your LaunchPad. At the time of writing there is support for three types listed below (and the first two are included with the LaunchPad v1.5):

• MSP430G2553 - <=16 MHz, 16KB flash, 512b SRAM, 24 GPIO, two 16-bit timers, UART, SPI, I2C, 8 ADC channels at 10-bit, etc. Cost around Au$3.80 each**
• MSP430G2452 - <=16 MHz, 8KB flash, 256b SRAM, 16 GPIO, one 16-bit timer, UART, I2C, 8 ADC channels, etc. Cost around Au$2.48 each**
• MSP430G2231 - <=16 MHz, 2KB flash, 128b SRAM, 10 GPIO, one 16-bit timer, SPI, I2C, 8 ADC channels, etc. Cost around Au$3.36 each**

** One-off ex-GST pricing from element14 Australia. In some markets it would be cheaper to buy another LaunchPad. TI must really be keen to get these in use.

There are some hardware<>sketch differences you need to be aware of. For example, how to refer to the I/O pins in Energia? A map has been provided for each MSP430 at the Energia wiki, for example the G2553:

As you can imagine, MSP430s are different to an AVR, so a lot of hardware-specific code doesn’t port over from the world of Arduino. One of the first things to remember is that MSP430s are 3.3V devices. Code may or may not be interchangeable, so a little research will be needed to match up the I/O pins and rewrite the sketch accordingly. You can refer to pins using the hardware designator on the LaunchPad (e.g. P1_6) or the physical pin number. For example – consider the following sketch:

void setup() { 
 // initialize the digital pins as an output.
 pinMode(P1_0, OUTPUT); // LED 1
 pinMode(P1_6, OUTPUT); // LED 2
}

void loop() {
 digitalWrite(P1_6, HIGH); 
 digitalWrite(P1_0, HIGH); 
 delay(100); 
 digitalWrite(P1_6, LOW); 
 digitalWrite(P1_0, LOW); 
 delay(100); 
}

You could have used 2 (for physical pin 2) instead of P1_0 and 14 (physical pin … 14!) instead of P1_6. It’s up to you. Another quick example is this one – when the button is pressed, the LEDs blink a few times:

const int redLED = P1_0;
const int greenLED = P1_6;
const int button = P1_3; // button S2 (on the left)

int a = 0;
void setup()
{
 pinMode(redLED, OUTPUT);
 pinMode(greenLED, OUTPUT); 
 pinMode(button, INPUT_PULLUP); // note _PULLUP
 digitalWrite(redLED, LOW);
 digitalWrite(greenLED, LOW); 
}

void loop()
{
 if (digitalRead(button)==LOW)
 {
 for (a=0; a<10; a++)
 {
 digitalWrite(redLED, HIGH);
 digitalWrite(greenLED, LOW); 
 delay(200);
 digitalWrite(redLED, LOW);
 digitalWrite(greenLED, HIGH); 
 delay(200);
 }
 digitalWrite(redLED, LOW);
 digitalWrite(greenLED, LOW); 
 }
}

Due to the wiring of the LaunchPad, when you press the button, P1_3 is pulled LOW. For the non-believers, here it is in action:

So where to from here? There are many examples in the Energia IDE example menu, including some examples for the Energia libraries. At the time of writing there is: Servo, LiquidCrystal, IRremote, SPI, wire, MSPflash and Stepper. And as the Energia project moves forward more may become available. For help and discussion, head over to the 4-3-Oh forum and of course the Energia website. And of course there’s the TI MSP430 website.

Conclusion

Well that was interesting to say the least. If you have a project which needs to be low-cost, fits within the specifications of the MSP430, has a library, you’re not hung up on brand preference, and you just want to get it done – this is a viable option. Hopefully after time some of you will want to work at a deeper level, and explore the full IDEs and MSP430 hardware available from TI. But for the price, don’t take my word for it – try it yourself. 

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

Kit Review – AVR ISP Shield

Introduction

In the last few weeks I needed to flash some ATmega328P microcontrollers with the Arduino bootloader. There are a few ways of doing this, and one method is to use an AVR ISP shield. It’s a simple kit to assemble and use, so let’s  have look at the process and results.

As the kit is manufactured by Sparkfun, it arrives in typical minimalist fashion:

The kit includes the following items:

That’s it – no URL to instructions or getting started guide or anything. Luckily we have a bit of knowledge behind us to understand what’s going on. The PCB has all the components as SMT including the status LEDs, so the only soldering required is the shield header pins and the six or ten-connector for the programming cable. You receive enough header pins to fit everything except for both six and ten – you can have one or the other, but not both. Having some handy I thought adding my own socket would be a good idea, however the pins are placed too closed to the group of six, nixing that idea:

Assembly

After collecting all my regular soldering tools and firing up the ‘888 it was time to get to work:

The first thing to fit were the shield headers. A simple way to do this is to break off the required lengths:

… then fit them to a matching board:

… then you place the shield on top and solder the pins. After that I used some of my own headers to fit both six and ten-pin ISP headers – it never hurts to do both, one day you might need them and not have soldering equipment at the ready. Finally the zero-insertion force (ZIF) socket goes in last. Push the lever down so it lays flat before soldering. Then you’re finished:

Operation

Now to program some raw microcontrollers. Insert the shield into your board. We used Arduino IDE v1.0.1 without modifying the original instructions from the Arduino team. Now upload the “ArduinoISP” sketch which is in the Examples menu. Once this has been successful the PLS LED will breathe. You then insert the microcontroller into the ZIF socket and gently pull the lever down. The notch on the microcontroller must be on the right-hand side when looking at the shield. Finally – check the voltage! There is a switch at the bottom-left of the shield that allows 5V or 3.3V. This only changes the Vcc so programming a 3.3V microcontroller will still involve 5V via SPI – possibly causing trouble.

Next  you need to select the target board for the microcontroller you’re programming. For example, if it’s going into a Uno – click Uno, even if you’re hosting the shield with an older board such as a Duemilanove. Next, choose the programmer type by selecting Tools > Programmer >  Arduino as ISP. Now for the magic – select Tools > Burn bootloader. The process takes around one minute, during which time the “PROG” LED on the shield will blink and flicker. It turns off once finished, and the IDE also notifies you of this. For the curious, the process is in the video below:

As you hopefully noticed earlier a cable is included which allows in-circuit programming from the shield to your existing project or prototype. However we didn’t have use for it at this time, it will come in handy when doing more advanced work later on.

Conclusion

It’s simple and it works. So if you need to flash a whole tube of raw micros with the Arduino bootloader, this is an option. In Australia you can get the kit from Little Bird Electronics. Full-sized images available on flickr. This kit was purchased without notifying the supplier.

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

Internet-controlled relays with teleduino and Freetronics RELAY8:

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

Updated 24/11/2012

In this article we’re going to look at controlling relays over the Internet. In doing so you will then be able to turn almost anything on and off as long as you have http access on an Internet-enabled device. Why would you want to do this? Connect an outdoor light – and turn it on before arriving home. Control the power to your TV setup – then you can control childrens’ TV viewing at a whim. Control farm water pumps without getting out of the truck. We’ll break this down into two stages. First we’ll explain how the RELAY8: relay control shield works and control it locally, then control it remotely using the teleduino service. We will be using Arduino IDE v1.0.1.

This tutorial will assume you have an understanding from three other articles – so please have a quick read of I2C bus, the MCP23017 I/O expander and teleduino. But don’t panic – we’ll try and keep it simple here.

The RELAY8: shield

First – our relay shield. We’ll be using the Freetronics RELAY8: shield:

Using the RELAY8: you can control eight relays using the I2C bus and the MCP23017 I/O expander – which saves your digital outputs for other purposes. There are three hardware settings you need to consider when using the shield:

1. Power – how will you power the relay coils?
   • You can directly connect between 5 and 24V DC using the terminal block on the right-hand side of the shield – great for stronger relay coils.
   • You can power the relay coils using power from the Arduino. So whatever power is going to the Arduino Vin can power the shield. To do this jumper the two pins next to the Vin shield connector. In doing so – you must check that the combined current draw of all your relays on at once will not exceed what is available to the Arduino. Usually OK when using solid-state relays, as most examples use around 15mA of current to activate. However double-check your relay specifications before doing so.
   • You can also power the Arduino board AND the shield by feeding in external power to the shield and jumpering the two pins described above
2. Which I2C address to use for each shield? By default it is 0×20. However you can alter the last three bits of the address by changing the jumpers at the bottom-left of the shield. Each jumper represents one bit of the bus address – no jumper means zero, and a jumper means one. So if you jumper ADDR0, the address will be 0×21 – etc. Using this method you can then stack up to eight shields – and control 64 relays!
3. Are you using an Arduino Leonardo board? If so – your shield I2C pins aren’t A4/A5 – they’re over near the top of the board:

However this isn’t a problem. Solder in some header pins to the shield’s SCL/SDA holes (next to AREF). Then turn over the RELAY8: board and you will see some solder pads as shown below. With a thin knife, cut the copper tracks shown with the blue lines:

Doing this will redirect the I2C bus from the microcontroller to the correct pins at the top-left.

Once you have decided on your power and I2C-bus options, it’s time to connect the relays. Doing so is simple, just connect the +  and – from the relay coil to the matching position on your RELAY8: shield, for example:

Today we’re just using prototyping wires, so when creating a permanent installation ensure the insulation reaches the terminal block. When working with relays you would use a diode across the coil to take care of back-EMF – however the shield has this circuitry, so you don’t need to worry about that at all. And if you’re wanting to control more than one shield – they stack nicely, with plenty of clearance between shields, for example:

Now to test the shield with a quick demonstration. Our sketch will turn on and off each relay in turn. We use the addressing format described in table 1.4 of the MCP23017 data sheet,  The relays 1 to 8 are controlled by “bank A” of the MCP23017 – so we need to set that to output in our sketch, as shown below (download sketch):

// Example 47.1
#include "Wire.h" // for I2C bus
#define I2C_ADDR 0x20 // 0x20 is the address with all jumpers removed

void setup()
{
 Wire.begin(); // Wake up I2C bus

 // Set I/O bank A to outputs
 Wire.beginTransmission(I2C_ADDR);
 Wire.write(0x00); // IODIRA register
 Wire.write(0x00); // Set all of bank A to outputs
 Wire.endTransmission();
}

int period = 500;

void loop()
{
 byte relay = 1;
 for (int i=1; i<9; i++)
 {
 // turn on relay 
 Wire.beginTransmission(I2C_ADDR);
 Wire.write(0x12); // Select bank A
 Wire.write(relay); // Send value to bank A
 Wire.endTransmission(); 
 delay(period);

// turn off all relays
 Wire.beginTransmission(I2C_ADDR);
 Wire.write(0x12); // Select bank A
 Wire.write(0); // Send value to bank A
 Wire.endTransmission(); 
 delay(period);

 relay = relay * 2; // move to next relay
 }
}

The sketch simply sends the values of 1, 2, 4, 8, 16, 32, 64 and 128 to the shield – each value in turn represents relays 1 to 8. We send 0 to turn off all the relays. Here’s a quick video showing it in action – the LEDs on the shield show the relay coil power status:

Now there is one small caveat – every time you send a new command to the MCP23017, it overwrites the status of the whole bank of pins. For example if relay 3 is on, and we send the value 2 – this will turn on relay 2 and turn off 3. Why? Because the values are converted to binary when heading down to the relay shield. So if we send 1, in binary this is:

00000001

which turns on relay 1 – and turns off relays 2 to 7. But then if we send 4 to turn on relay 3, in binary this is:

00000100

which turns on relay 3, but turns off relays 1, 2, and 4 to 8. So how do we turn on or off all eight relays at once? Just do a little binary to decimal conversion. Let’s say you want relays 1, 3, 5 and 7 on – and 2, 4, 6 and 8 off. In binary our command value would be:

01010101

and in decimal this is 85. Want to turn them all on at once? Send 255. Then all off? Send zero.

Now let’s do it via the Internet…

You’re going to need an Ethernet-enabled Arduino board. This could involve adding an Ethernet shield to your existing board, or using an all-in-one board like the Freetronics EtherTen. We will now use the teleduino service created by Nathan Kennedy to send commands to our Arduino boards via the Internet. At this point, please review and understand the teleduino article – then, when you can successfully control a digital output pin – return here to continue.

First, get the hardware together. So ensure your relay shield is in the Arduino and you have uploaded the

TeleduinoEthernetClientProxy.ino

sketch. For the first couple of times, it’s good to still have the teleduino status LED connected – just to keep an eye on it. Plug your Arduino into your router and the power. After it connects to teleduino (four blinks of the status LED) we have to send three commands via http. The first tells teleduino that we’re sending I2C commands. You only do this once after every Arduino reset or power-up situation. It is:

https://us01.proxy.teleduino.org/api/1.0/328.php?k=999999r=defineWire

Remember to replace 999999 with your teleduino key. Then we send:

https://us01.proxy.teleduino.org/api/1.0/328.php?k=999999&r=setWire&address=32&bytes=%00%00

At this stage the relay shield is now ready to accept your bytes to turn on and off the outputs. Again, just like the sketch – we send two bytes. For example:

 https://us01.proxy.teleduino.org/api/1.0/328.php?k=999999&r=setWire&address=32&bytes=%12%FF

turns on all the outputs – however with the URL we need to send the byte representing the outputs in hexadecimal. So 255 is FF, 0 is 0, etc. For example to turn them all off, use:

https://us01.proxy.teleduino.org/api/1.0/328.php?k=999999&r=setWire&address=32&bytes=%12%00

or to turn on outputs 1, 2, 3 and 4 use:

https://us01.proxy.teleduino.org/api/1.0/328.php?k=999999&r=setWire&address=32&bytes=%12%0F

Simple. You can simply bookmark your URLs for later use as well – and don’t forget to use a URL-shortener such as bit.ly to makes things simpler for you.

Conclusion

Now you have a way to control many relays either locally or remotely over the Internet. I hope you found this article useful or at least interesting. If you have any suggestions for further articles (and not thinly-veiled methods of asking me to do your work for you…) – email them to john at tronixstuff dot com. Thanks to Freetronics for the use of their hardware and Nathan Kennedy for teleduino, his support and advice.

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.

Adventures with SMT and a POV SMT Kit

Introduction

There’s a lot of acronyms in the title for this article – what I wanted to say was “Adventures with surface-mount technology soldering with the Wayne & Layne Blinky Persistence-of-vision surface-mount technology reprogrammable light emitting diode kit…” No, seriously. Anyhow – after my last attempt at working with hand soldering surface-mount components couldn’t really be called a success, I was looking for something to start again with. After a little searching around I found the subject for today’s review and ordered it post-haste. Delivery from the US to Australia was twelve calendar days – which is pretty good, so you know the organisation is shipping quickly once you paid.

The kit is by “Wayne and Layne” which was founded by two computer engineering graduates. They have a range of open-source electronics kits that look like fun and a lot of “blinkyness”. Our POV kit is a simple persistence-of-vision display. By using eight LEDs in a row you can display words and basic characters by waving the thing through the air at speed, giving the illusion of a larger display. An analogy to this would be a dot-matrix printer that prints with ink which only lasts a fraction of a second. More on that later, first – putting it together.

Assembly

Like most other kits it arrived in an anti-static bag, with a label clearly telling you where the instructions are:

Upon opening the amount of items included seemed a little light:

However the instructions are detailed:

… and upon opening, reveal the rest of the components:

… which are taped down to their matching description on the cardboard. When cutting the tape to access the parts, do it slowly otherwise you might send them flying off somewhere on the bench and spend ten minutes looking for it. Finally, the PCB in more detail:

After reviewing the instructions, it was time to fire up my trusty Hakko and get started. At this point a few tools will come in handy, including SMT tweezers, some solder wick and a piece of blu-tac:

Following the instructions, and taking your time are the key to success. When mounting the two-pad components – put a blob of solder on one pad, then use tweezers to move the component in whilst keeping that pad of solder molten, remove the iron, then let go with the tweezers. Then the results should resemble capacitor C1 on the board as shown below:

Then a quick blob at the other end seals it in. This was easily repeated for the resistors. The next step was the pre-programmed PIC microcontroller. It is in the form of a SOIC package type, and required some delicate work. The first step was to stick it down with some blu-tac:

… then solder down one pin at each end. Doing so holds it in place and you can remove the blu-tac and solder the rest of the pins in. I couldn’t solder each pin individually, so dragged solder across the pins then tried to soak up the excess with solder wick. I didn’t find this too successful, so instead used the solder sucker to mop up the excess:

If you solder, you should get one of these – they’re indispensable. Moving forward, the PIC finally sat well and looked OK:

Next was the power-switch. It clicks neatly into the PCB making soldering very easy. Then the LEDs. They’re tiny and some may find it difficult to identify the anode and cathode. If you look at the top, there is a tiny dot closer to one end – that end is the cathode. For example, in the lineup:

Soldering in the LEDs wasn’t too bad – however to save time do all the anodes first, then the cathodes:

At this point all the tricky work is over. There are the light-sensor LEDs and the reset button for the top:

And the coin-cell battery holder for the bottom. The battery is also included with the kit:

Operation

Once you’ve put the battery in, turn it on and wave it about in front of yourself. There are some pre-programmed messages and symbols already loaded, which you can change with the button. However you’ll want to put your own messages into the POV – and the process for doing so is very clever. Visit the programming page, and follow the instructions. Basically you enter the text into the form, set the POV to programming mode – and hold it up against two squares on your monitor. The website will then blink the data which is received by the light-sensitive LEDs. Once completed, the POV will inform you of success or failure. This method of programming is much simpler than having to flash the microcontroller every time – well done Wayne and Layne. A pin and connector is also included which allows you to wear the blinky as a badge. Maybe at a hackerspace, but not in public.

Once programmed some fun can be had trying out various speeds of waving the blinky. For example, here it is with the speed not fast enough at all:

… and a little bit faster:

And finally with me running past the camera:

Furthermore, there is an ‘easter egg’ in the software, which is shown below:

Conclusion

We had a lot of fun with this simple little kit, and learned a thing or two about hand-soldering SMT. It can be done with components that aren’t too small – however doing so was an interesting challenge and the results were quite fun. So it met our needs very well. Anyone can do it with some patience and a clean soldering iron. You can order the Blinky POV SMT kit directly from Wayne & Layne. Full-sized images available on flickr. This kit was purchased without notifying the supplier.

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

Initial review: Aery32 Atmel AVR32 UC3A1 Development Board

Introduction

Recently (!) one of my readers sent me the subject of our review – the Aery32 development board from Finland. Based around the Atmel AVR32 UC3A1 128KB microcontroller – it is a painless way to get into AVR32 programming and development. Furthermore the hardware and software are completely open-source, so you can make your own and modify to your heart’s content. The specifications of the Atmel AVR32 UC3A1 show that it is an incredibly powerful microcontroller and they can be found in detail from Atmel here - plus you can download the data sheet from here.

Regular readers will know that I don’t work with this platform, so this review is written from the point of an absolute beginner. My apologies if some of the terminology used isn’t the norm. Moving forward, here is our Aery32 board:

… and the rear:

One could say that there is everything you need – and nothing you do not. Looking at the front of the board, apart from the MCU there is an LED for use, the mini-USB for programming and a switch for changing modes between the bootloader and program. On the rear are the pin references, and on the right-hand side solder pads (on both sides) for the JTAG debugger.  The following video is a short walkthrough:

Setup

The first thing to do is get the required software installed on the machine. Instructions for Windows, MacOS and Linux are provided. Here we have Windows 7 and the installation was simple – the Atmel software installed painlessly enough. You will also need the Aery32 software framework, which contains source files and compiling instructions for your projects. This is updated over time by the Aery32 project, so keep an eye on the github page.

After downloading the framework, keep an unaltered copy in a folder. Then you copy this and rename it for each new project. That is - for each project you start with a fresh framework folder and insert the code into the main.cpp file within the folder. Consider the following:

You can see how I have kept the framework in a folder to keep as a source, then made copies and renamed them for individual projects. Then inside each folder you have the various files – and the main.cpp which contains your project code.

Using the Aery32

From the beginning I was a little worried due to my lack of time and inexperience with AVR32 programming. However after determing how the software framework and code files are used as described earlier – the process of programming the board was easy. You then just need to learn how to program – a topic for another day… In the meanwhile, blinking the LED as a test was simple enough. After making a separate folder (see the image above) one simply edits the main.cpp file and adds the required code. For example – to blink the onboard LED:

#include "board.h"
#include <aery32/all.h>
using namespace aery;
int main(void)
{
 /* Put your application initialization sequence here */
 init_board();
 gpio_init_pin(LED, GPIO_OUTPUT);
for(;;) {
 gpio_toggle_pin(LED);
 delay_ms(250);
}
 return 0;
}

Next, make sure the switch on the Aery32 is moved towards the reset button – this puts the board into bootloader mode. Plug in the USB cable, wait for recognition – then from the command prompt, navigate to the folder which contains the code and enter make program start. If all goes well you will see the following:

And if it doesn’t, the various errors are described as necessary. As you can see all the compilation and uploading is scripted for you making the whole process very simple. Then move the switch away from the reset button – which puts the board in run mode, then press reset. For anything further you’re going to need some external wiring – so for further experimenting purposes the first thing I did was solder in some standard 0.1″ dual inline header pins to allow easy access to a variety of I/O pins and GND. Although wanting to do more I’m pretty time-constrained at the moment so came up with not one but four blinking LEDs. Here’s the code:

#include "board.h"
#include <aery32/all.h>

using namespace aery;

int main(void)
{
 /* Put your application initialization sequence here */
 init_board();
 // set I/O pins to output

gpio_init_pin(AVR32_PIN_PA00, GPIO_OUTPUT);
 gpio_init_pin(AVR32_PIN_PA01, GPIO_OUTPUT);
 gpio_init_pin(AVR32_PIN_PA02, GPIO_OUTPUT);
 gpio_init_pin(AVR32_PIN_PA03, GPIO_OUTPUT);

for(;;) {

gpio_toggle_pin(AVR32_PIN_PA00);
 delay_ms(250);
 gpio_toggle_pin(AVR32_PIN_PA01);
 delay_ms(250);
 gpio_toggle_pin(AVR32_PIN_PA02);
 delay_ms(250);
 gpio_toggle_pin(AVR32_PIN_PA03);
 delay_ms(250);
 }
 return 0;
}

and for the non-believers – the board in action:

Aery32-specific information and help is easy to find. For an open-source project, the documentation is extensive and includes many examples. Have a look around the documentation site to see what I mean. There is also a developer area which contains many articles about using the Aery32 and various examples within.

Conclusion

From my (beginner’s) perspective this board was very easy to setup and get working. Not having to worry about downloading hundreds of megabytes of IDE was great and allows programming from lightweight machines. And there is no doubt about the power or I/O features of the AVR32 UC3A1. Now I’ll get myself a good AVR32 book. So if you’re looking for a powerful and well-supported AVR32 development board, the Aery32 is a good start. You can order the board directly from the website at http://www.aery32.com/.

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