Introducing Goldilocks – the Arduino Uno-compatible with 1284p and uSD card

[Update 19/03/2013 - the project is now fully funded. When the boards arrive we'll do a full review]

Introduction

It’s a solid fact that there are quite a few variations on the typical Arduino Uno-compatible board. You can get them with onboard wireless, GSM, Zigbee and more – however all with their own issues and specific purposes. But what if you wanted a board that was physically and electrically compatible with an Arduino Uno – but with much more SRAM, more EEPROM, more flash, more speed – and then some? Well that (hopefully) will be a possibility with the introduction of the “Goldilocks” board on Pozible by Phillip Stevens.

What’s Pozible?

Pozible is the Australian version of Kickstarter. However just like KS anyone with a credit card or PayPal can pledge and support projects.

What’s a Goldilocks board?

It’s a board based around the Atmel ATmega1284p microcontroller in an Arduino Uno-compatible physical board with a microSD card socket and a few extras. The use of the ’1284p gives us the following advantages over the Arduino Uno, including:

• 16 kByte SRAM = 8x Uno SRAM – so that’s much more space for variables used in sketches – great for applications that use larger frame buffers such as Ethernet and image work;
  
• 2 kByte EEPROM = 2 x Uno EEPROM – giving you more space for non-volatile data storage on the main board;
• 128 kByte flash memory = 4 x Uno – giving you much, much more room for those larger sketches;
• Two programmable USARTS – in other words, two hardware serial ports – no mucking about with SoftwareSerial and GSM or GPS shields;
• Timer 3 – the ’1284p microcontroller has an extra 16-bit timer – timer 3, that is not present on any other ATmega microcontroller. Timer 3 does not have PWM outputs (unlike Timer 0, Timer 1, and Timer 2), and therefore is free to use as a powerful internal Tick counter, for example in a RTOS. freeRTOS has already been modified to utilise this Timer 3;
• JTAG interface – yes – allowing more advanced developers the opportunity to debug their code;
• better PWM access – the 1284p brings additional 8-bit Timer 2 PWM outputs onto PD, which creates the option for 2 additional PWM options on this port. It also removes the sharing of the important 16-bit PWM pins with the SPI interface, by moving them to PD4 & PD5, thus simplifying interface assignments;
• Extra I/O pins – the 1284p has additional digital I/O pins on the PB port. These pins could be utilised for on-board Slave Select pins (for example), without stealing on-header digital pins and freeing the Arduino Pin 10 for Shield SPI SS use exclusively;

Furthermore the following design improvements over an Arduino Uno:

• adding through-holes for all I/O – allowing you to solder directly onto the board whilst keeping header sockets;
• replicate SPI and I2C for ease of use;
• microSD card socket – that’s a no-brainer;
• link the ATmega16u2 and ATmega1284p SPI interfaces – this will allow the two devices to work in concert for demanding multi-processing applications, involving USB and other peripherals;
• Fully independent analogue pins, including seperate AVCC and GND – helps reduce noise on the ADC channels for improved analogue measurement accuracy;
• move the reset button to the edge of the board – another no-brainer
• clock the board at 20 MHz – that’s an extra 4 MHz over a Uno. And the use of a through hole precision crystal (not a SMD resonator) allows the use of after market timing choices, eg 22.1184 MHz for more accurate UART timings.

What does it look like? 

At the moment the board mock-up looks like this:

If funding is successful (and we hope it will be) the Goldilocks will be manufactured by the team at Freetronics. Apart from being a world-leader in Arduino-compatible hardware and systems, they’re the people behind the hardware for Ardusat and more – so we know the Goldilocks will be in good hands.

Will it really be compatible?

Yes – the Goldilocks will be shipped pre-programmed with an Arduino compatible boot-loader, and the necessary Board description files will be available to provide a 100% compatible Arduino IDE experience.

Conclusion

If you think this kind of board would be useful in your projects, you want to support a good project – or both, head over to Pozible and make your pledge. And for the record – I’ve put my money where my mouth is

Please note that I’m not involved in nor responsible for the Goldilocks project, however I’m happy to promote it as a worthwhile endeavour. 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.

First look: Arduino Due

Updated 27/02/2013

Introduction

After much waiting the Arduino Due has been released, so let’s check it out. We’ll run through the specifications and some areas of interest, see what’s different, some random notes – then try out some of the new features. Before moving forward note that it might look the same - the Due is not a drop-in replacement for older boards – even the Mega2560. It’s different.

First announced in late 2011, the Due is the Arduino team’s first board with a 32-bit processor – the Atmel SAM3X8E ARM Cortex-M3 CPU. With an 84 Mhz CPU speed and a host of interfaces and I/O, this promises to be the fastest and most functional Arduino board ever. According to the official Arduino press release:

Arduino Due is ideal for those who want to build projects that require high computing power such as the remotely-controlled drones that, in order to fly, need to process a lot of sensor data per second.
Arduino Due gives students the opportunity to learn the inner workings of the ARM processor in a cheaper and much simpler way than before.
To Scientific projects, which need to acquire data quickly and accurately, Arduino Due provides a platform to create open source tools that are much more advanced than those available now.
The new platform enables the open source digital fabrication community (3d Printers, Laser cutters, CNC milling machines) to achieve higher resolutions and faster speed with fewer components than in the past.

Sounds good – and the Due has been a long time coming, so let’s hope it is worth the wait. The SAM3X CPU holds a lot of promise for more complex projects that weren’t possible with previous ATmega CPUs, so this can be only a good thing.

Specifications

First of all, here’s the Due in detail – top and bottom (click to enlarge):

You can use Mega-sized protoshields without any problem (however older shields may miss out on the upper I2C pins) – they’ll physically fit in … however their contents will be a different story:

The specifications of the Due are as follows (from Arduino website):

Microcontroller		AT91SAM3X8E
Operating Voltage		3.3V
Input Voltage (recommended)		7-12V
Input Voltage (limits)		6-20V
Digital I/O Pins		54 (of which 12 provide PWM output)
Analog Input Pins		12
Analog Outputs Pins		2 (DAC)
Total DC Output Current on all I/O lines		130 mA
DC Current for 3.3V Pin		800 mA
DC Current for 5V Pin		800 mA
Flash Memory		512 KB all available for the user applications
SRAM		96 KB (two banks: 64KB and 32KB)
Clock Speed		84 MHz

Right away a few things should stand out – the first being the operating voltage – 3.3V. That means all your I/O needs to work with 3.3V – not 5V. Don’t feed 5V logic line into a digital input pin and hope it will work – you’ll damage the board. Instead, get yourself some logic level converters. However there is an IOREF pin like other Arduino boards which intelligent shields can read to determine the board voltage. The total output current for all I/O lines is also 130 mA … so no more sourcing 20mA from a digital ouput for those bright LEDs.

The power regulator for 5V has been changed from linear to switching – so no more directly inserting 5V into the 5V pin. However the 3.3V is through an LDO from 5v.

Each digital I/O pin can source 3 or 15 mA – or sink 6 or 9 mA … depending on the pin. High-current pins are CAN-TX, digital 1, 3~12, 23~51, and SDA1. The rest are low current. And there’s still an LED on digital 13. You will need to redesign any existing projects or shields if moving to the Due.

The analogue inputs now have a greater resolution – 12-bits. That means it can return a value of  0~4095 representing 0~3.3V DC. To activate this higher resolution you need to use the function analogReadResolution(12).

Memory – there isn’t any EEPROM in the SAM3X – so you’ll need external EEPROMs to take care of more permanent storage. However there’s 512 KB of flash memory for sketches – which is huge. You have to see it to believe it:

Excellent. A new feature is the onboard erase button. Press it for three seconds and it wipes out the sketch. The traditional serial line is still digital 0/1 – which connect to the USB controller chip.

Hardware serial – there’s four serial lines. Pulse-width modulation (PWM) is still 8-bit and on digital pins 2~13.

The SPI bus is on the ICSP header pins to the right of the microcontroller – so existing shields that use SPI will need to be modified – or experiment with a LeoShield:

You can also use the extended SPI function of the SAM3X which allow the use of digital pins 4, 10 or 52 for CS (chip select).

The SAM3X supports the automtive CAN bus, and the pins have been brought out onto the stacked header connectors – however this isn’t supported yet in the IDE.

There are two I2C buses – located on digital 20/21 and the second is next to AREF just like on the Leonardo.

There’s a 10-pin JTAG mini-header on the Due, debug pins and a second ICSP for the ATmega16U2 which takes care of USB. Speaking of USB – there’s two microUSB sockets. One is for regular programming via the Arduino IDE and the USB interface, the other is a direct native USB programming port direct to the SAM3X.

The SAM3X natively supports Ethernet, but this hasn’t been implemented on the hardware side for the Due. However some people in the Arduino forum might have a way around that.

Using the Due

First of all – at the time of writing – you need to install Arduino IDE v1.5.1 release 2 – a beta version. Windows users – don’t forget the USB drivers. As always, backup your existing installation and sketch files somewhere safe – and you can run more than one IDE on the same machine.

When it comes time to upload your sketches, plug the USB cable into the lower socket on the Due – and select Arduino Due (Programming Port) from the Tools>Board menu in the IDE.

Let’s upload a sketch now (download) – written by Steve Curd from the Arduino forum. It calculates Newton Approximation for pi using an infinite series. As you can see from the results below, the Due is much faster (690 ms) than the Mega2560 (5765 ms). Click the image to enlarge:

Next, let’s give the digital-to-analogue converters a test. Finally we have two, real, 12-bit DACs with the output pins being … DAC0 and DAC1. No more mucking about with external R-C filters to get some audio happening. These pins provides true analogue outputs which is controlled by the analogWrite() function. To use them is very simple – consider the following example sketch which creates a triangle wave:

void setup() 
{
 analogWriteResolution(12); // 12-bit!
}

void loop() 
{
 for(int x=0; x<4096; x++) 
 {
 analogWrite(DAC0, x); // use DAC1 for ... DAC1
 }
 for(int x=4095; x>=0; --x) 
 {
 analogWrite(DAC0, x);
 }
}

And the results from the DSO (click image to enlarge):

This opens up all sorts of audio possibilities. With appropriate wavetable data saved in memory you could create various effects. However the DAC doesn’t give a full 0~3.3V output – instead it’s 1/6 to 5/6 of the Aref voltage. With the IDE there are example sketches that can play a .wav file from an SDcard – however I’d still be more inclined to use an external shield for that. Nevertheless for more information, have a look at the Audio library. Furthermore, take heed of the user experiences noted in the Arduino forum – it’s very easy to destroy your DAC outputs. In the future we look forward to experimenting further with the Due – so stay tuned.

Getting a Due

Good luck … at the time of writing – the Dues seem to be very thin on the ground. This may partly be due to the limited availability of the Atmel SAM3X8E. My contacts in various suppliers say volumes are quite limited.

Quality

I really hope this is a rare event, however one of the Dues received had the following fault in manufacturing:

One side of the crystal capacitor wasn’t in contact with the PCB. However this was a simple fix. How the QC people missed this … I don’t know. However I’ve seen a few Arduinos of various types, and this error is not indicative of the general quality of Arduino products.

Where to from here?

Visit the official Arduino Due page, the Due discussion section of the Arduino forum, and check out the reference guide for changes to functions that are affected by the different hardware.

Conclusion

Well that’s my first take on the Due – powerful and different. You will need to redesign existing projects, or build new projects around it. And a lot of stuff on the software side is still in beta. So review the Due forum before making any decisions. With that in mind – from a hardware perspective – it’s a great step-up from the Mega2560.

So if you’re interested – get one and take it for a spin, it won’t disappoint. The software will mature over time which will make life easier as well. If you have any questions (apart from Arduino vs. Raspberry Pi) leave a comment and we’ll look into it.

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.

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.

RF Wireless Data with the Seeedstudio RFbee

Introduction

In this article we examine the Seeedstudio RFbee Wireless Data Transceiver nodes. An RFbee is a small wireless data transceiver that can be used as a wireless data bridge in pairs, as well as a node in mesh networking or data broadcasting. Here is an example of an RFbee:

You may have noticed that the RFbee looks similar to the Xbee-style data transceivers – and it is, in physical size and some pinouts, for example:

However this is where the similarity ends. The RFbee is in fact a small Arduino-compatible development board based on the Atmel ATmega168 microprocessor (3.3V at 8MHz – more on this later) and uses a Texas Instruments CC1101 low-power sub1-GHz RF transceiver chip for wireless transfer. Turning over an RFbee reveals this and more:

But don’t let all this worry you, the RFbee is very simple to use once connected. As a transceiver the following specifications apply:

• Data rate – 9600, 19200, 38400 or 115200bps
• Adjustable transmission power in stages between -30dBm and 10 dBm
• Operating frequency switchable between 868MHz and 915MHz
• Data transmission can be point-to-point, or broadcast point-to-many
• Maximum of 256 RFbees can operate in one mesh network
• draws only 19.3mA whilst transmitting at full power

The pinout for the RFbee are similar to those of an Xbee for power and data, for example:

There is also the ICSP pins if you need to reprogram the ATmega168 direcly with an AVRISP-type programmer.

Getting Started

Getting started is simple – RFbees ship with firmware which allows them to simply send and receive data at 9600bps with full power. You are going to need two or more RFbees, as they can only communicate with their own kind. However any microcontroller with a UART can be used with RFbees – just connect 3.3V, GND, and the microcontroller’s UART TX and RX to the RFbee and you’re away. For our examples we will be using Arduino-compatible boards. If Arduino is new to you, consider our tutorials first.

If you ever need to update the firmware, or reset the RFbee to factory default after some wayward experimenting – download the firmware which is in the form of an Arduino sketch (RFBee_v1_1.pde) which can be downloaded from the repository. (This has been tested with Arduino v23). In the Arduino IDE, set the board type to “Arduino Pro or Pro Mini (3.3V, 8MHz) w/ATmega168″. From a hardware perspective, the easiest way to update the firmware is via a 3.3V FTDI cable or an UartSBee board, such as:

You will also find a USB interface useful for controlling your RFbee via a PC or configuration (see below). In order to do this,  you will need some basic terminal software. A favourite and simple example is called … “Terminal“. (Please donate to the author for their efforts).

Initial Testing

After connecting your RFbee to a PC, run your terminal software and set it for 9600 bps – 8 – None – no handshaking, and click the check box next to “+CR”. For example (click to enlarge):

Select your COM: port (or click “ReScan” to find it) and then “Connect”. After a moment “OK” should appear in the received text area. Now, get yourself an Arduino or compatible board of some sort that has the LED on D13 (or substitute your own) and upload the following sketch:

// RFbee demonstration sketch

int ledPin = 13;
byte incoming=0;

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

void blinkLED(int i)
{
  for (int a=0; a<i; a++)
  {
    digitalWrite(ledPin, HIGH);
    delay(250);
    digitalWrite(ledPin, LOW);
    delay(250);
  }
}

void loop()
{
  if (Serial.available() > 0)
  {
    incoming = Serial.read();
    switch(incoming)
    {
      case 'A':
      blinkLED(1);
      break;
      case 'B':
      blinkLED(2);
      break;
      case 'C':
      blinkLED(3);
      break;
      default:
      blinkLED(5);

   }

  Serial.println("Blinking completed!");
  delay(2000);
  Serial.flush();
  }
}

Finally, connect the Arduino board to an RFbee in this manner:

• Arduino D0 to RFbee TX
• Arduino D1 to RFbee RX
• Arduino 3.3V to RFbee Vcc
• Arduino GND to RFbee GND

and the other RFbee to your PC and check it is connected using the terminal software described earlier. Now check the terminal is communicating with the PC-end RFbee, and then send the character ‘A’, ‘B’ or ‘C’. Note that the LED on the Arduino board will blink one, two or three times respectively – or five times if another character is received. It then reports back “Blinking completed!” to the host PC. For example (click to enlarge):

Although that was a very simple demonstration, in doing so you can prove that your RFbees are working and can send and receive serial data. If you need more than basic data transmission, it would be wise to get a pair of RFbees to experiment with before committing to a project, to ensure you are confident they will solve your problem.

More Control

If you are looking to use your RFbees in a more detailed way than just sending data at 9600 bps at full power, you will need to  control and alter the parameters of your RFbees using the terminal software and simple AT-style commands. If you have not already done so, download and review the RFbee data sheet downloadable from the “Resources” section of this page. You can use the AT commands to easily change the data speed, power output (to reduce current draw), change the frequency, set transmission mode (one way or transceive) and more.

Reading and writing AT commands is simple, however at first you need to switch the RFbee into ‘command mode’ by sending +++ to it. (When sending +++ or AT commands, each must be followed with a carriage return (ASCII 13)). Then you can send commands or read parameter status. To send a command, just send AT then the command then the parameter. For example, to set the data rate (page ten of the data sheet) to 115200 bps, send ATBD3 and the RFbee will respond with OK.

You can again use the terminal software to easily send and receive the commands. To switch the RFbee from command mode back to normal data mode, use ATO0 (that’s AT then the letter O then zero) or power-cycle the RFbee.

RFbee as an Arduino-compatible board with inbuilt wireless

As mentioned previously the RFbee is based around an Atmel ATmega168 running at 8MHz with the Arduino bootloader. In other words, we have a tiny Arduino-compatible board in there to do our bidding. If you are unfamiliar with the Arduino system please see the tutorials listed here. However there are a couple of limitations to note – you will need an external USB-serial interface (as noted in Getting Started above), and not all the standard Arduino-type pins are available. Please review page four of the data sheet to see which RFbee pins match up to which Arduino pins.

If for some reason you just want to use your RFbee as an Arduino-compatible board, you can do so. However if you upload your own sketch you will lose the wireless capability. To restore your RFbee follow the instructions in Getting Started above.

The firmware that allows data transmission is also an Arduino sketch. So if you need to include RF operation in your sketch, first use a copy of the RFBee_v1_1.pde included in the repository – with all the included files. Then save this somewhere else under a different name, then work your code into the main sketch. To save you the effort you can download a fresh set of files which are used for our demonstration. But before moving forward, we need to learn about controlling data flow and device addresses…

Controlling data flow

As mentioned previously, each RFbee can have it’s own numerical address which falls between zero and 255. Giving each RFbee an address allows you to select which RFbee to exchange data with when there is more than two in the area. This is ideal for remote control and sensing applications, or to create a group of autonomous robots that can poll each other for status and so on.

To enable this method of communication in a simple form several things need to be done. First, you set the address of each RFbee with the AT command ATMAx (x=address). Then set each RFbee with ATOF2. This causes data transmitted to be formatted in a certain method – you send a byte which is the address of the transmitting RFbee, then another byte which is the address of the intended receipient RFbee, then follow with the data to send. Finally send command ATAC2 – which enables address checking between RFbees. Data is then sent using the command

transmitData(*byte data, byte length, byte sourceAddress, byte destinationAddress)

Where data is … the data to send. You can send a single byte, or an array of bytes. length is the number of bytes you are sending. sourceAddress and destinationAddress are relevant to the RFbees being used – you set these addresses using the ATMAx described earlier in this section.

If you open the file rfbeewireless.pde in the download bundle, scroll to the end of the sketch which contains the following code:

byte testData[4] = {'A','B','C','D'};

void sendTestData()
{
 // send the four bytes of data in the byte testData[] from address 1 to address 2
 transmitData(testData,4,1,2);
 delay(1000);
}

This is a simple example of sending data out from the RFbee. The RFbee with this sketch (address 1) sends the array of bytes (testdata[]) to another RFbee with address 2.  You can disable address checking by a receiving RFbee with ATAC0 – then it will receive any data send by other RFbees.

To receive data use the following function:

result=receiveData(rxData, &len, &sourceAddress, &destinationAddress, (byte *)&rssi , &lqi);

The variable result will hold the incoming data, len is the number of bytes to expect, sourceAddress and destinationAddress are the source (transmitting RFbee) and destination addresses (receiving RFbee). rssi and lqi are the signal strength and link quality indicator – see the TI CC1101 datasheet for more information about these. By using more than two RFbees set with addresses you can selectively send and receive data between devices or control them remotely. Finally, please note that RFbees are still capable of sending and receiving data via the TX/RX pins as long as the sketch is not executing the sendTestData() loop.

I hope you found this introduction interesting and useful. The RFbees are an inexpensive and useful alternative to the popular Xbee modules and with the addition of the Arduino-compatible board certainly useful for portable devices, remote sensor applications or other data-gathering exercises.

For more information and product support, visit the Seeedstudio product pages.

RFbees are available from Seeedstudio and their network of distributors.

Disclaimer - RFbee products used in this article are promotional considerations made available by Seeedstudio.

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.

Results – February 2012 Competition

Now that February is over it’s time to announce the lucky winners of our February competition…

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

Winner of the first prize is Rosemary H from the United Kingdom.

Prize Two is awesome – and a mystery no more. It is the new Freetronics LeoStick:

From the Freetronics website:

The LeoStick is just like the upcoming Arduino Leonardo, but given the “honey, I shrunk the kids” treatment!
Just pop it into your USB port (no cable required!) and upload straight from the Arduino IDE. We’ve even included on-board RGB LED lights and a speaker in this handy sized board. All the usual Arduino pins are present and each LeoStick comes with low profile header sockets for plugging in modules, shields and wires.

Winner of the second prize is Andrian from Moldova. Congratulations to the winners and thanks to everyone for entering.

For the curious, the questions and answers were:

1. What frequency crystal would you use with the DS1307 RTC? – 32.768kHz
2. How many LEDs are on an EtherMega board? Now I have two answers as the question should have been more specific. There are ten LEDs on the actual PCB, plus two more on the ethernet socket. So we accepted ten or twelve for the answer
3. What are the dimensions (length x width) of an 0805 SMT component in mm? – 2.0 x 1.3 mm
4. In what year was Ikea founded? – 1943
5. What nationality is the Hakko company? Japanese
6. Who came up with the name for the device known as the ‘transistor‘? - John R. Pierce

Finally, thank you for your competition entries – I really appreciate it. So in that spirit we will have another competition in March – so stay tuned using one of the methods below.

Once again, thanks to Freetronics for the EtherMega and LeoStick prizes!

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.

February 2012 Competition

Update – The competition has now finished, and the winners will be announced shortly…

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 EtherMega combines 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 – and a mystery no more. It is the new Freetronics LeoStick:

From the Freetronics website:

The LeoStick is just like the upcoming Arduino Leonardo, but given the “honey, I shrunk the kids” treatment!
Just pop it into your USB port (no cable required!) and upload straight from the Arduino IDE. We’ve even included on-board RGB LED lights and a speaker in this handy sized board. All the usual Arduino pins are present and each LeoStick comes with low profile header sockets for plugging in modules, shields and wires.

Features of the LeoStick include:

• Native USB port built-in, no need for any USB or FTDI cables
• Two Full Color RGB LEDs on-board! Drive different colored outputs and fun feedback from your sketch right away. One RGB LED is completely programmable, the other does Power, USB RX and TX indication, the RX and TX LEDs can also be controlled.
• On-board Piezo speaker element, play sounds, tunes and beeps. Can also be used as a knock/vibration sensor
• Same I/O pins. The LeoStick provides all the same header connections as larger boards, you can connect all the same sensors, actuators, and other inputs and outputs as typical Arduino models.
• Breadboard compatible, has 0.1″ pitch pads and header pins can be fitted underneath
• 500mA polyfuse and protection on the USB port
• ATmega32U4 microcontroller, Arduino compatible with on-board USB, 32K Flash, 2.5K RAM, 1K EEPROM at 16MHz
• ISP 6-pin connector for advanced programming of the ATmega32U4 MCU

Please note: The LeoStick currently uses a modified beta version of the upcoming Arduino Leonardo bootloader. There are some known issues with Windows 7 64-bit drivers and some library functions don’t work perfectly yet. Any firmware or Arduino Leonardo compatible support should not be considered to be final release firmware or in any way an official Arduino. Don’t hassle the Arduino team with support or requests related to this board: they’re solely our responsibility. The LeoStick is also a very complete ATmega32U4 breakout and USB board by itself and the LeoStick can be programmed directly from the supplied standard ISP header by AVR Studio, Mac OSX-AVR, avrdude, WinAVR etc.

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 and LeoStick prizes!

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.

Results – January 2012 Competition

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.

January 2012 Competition

Hello Readers

The competition has now ended and the winning entry will be announced shortly. Thank you to all those who entered, and of course to Akafugu for their prize this month.

It’s that time of the month again so we are running another competition. Our prize for this month consists of two items:

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

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

— *** How to Enter *** —

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

During the second week of February, all the correct entries will be collated and one randomly chosen. The first correct entry drawn will win the prize. Entries will be accepted until 03/02/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;
• 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/02/2012 0005h GMT.

Thanks to Akafugu for offering the Akafuino-X prize!

So have fun and keep an eye out for the four competition questions spread through the January 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.

Initial Review: Akafuino-X Microcontroller Board

Hello Readers

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

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

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

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

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

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

Other changes include:

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

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

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

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

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

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

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

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

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.

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

September 2011 Competition

Hello readers!

The September competition has now closed for entries. Thank you to all those who entered, there have been some very original and creative entries. The winners will be announced in the next seven days.

Another month – another competition! This month the method of entry will be slightly different. First of all, let’s have a look at the prizes:

*** First prize is TWO demonstration Zigduinos – courtesy of Logos Electromechanical ***

What’s a Zigduino? It is an Arduino-compatible microcontroller platform that integrates an 802.15.4 radio on the board. The radio can be configured to support any 802.15.4-based protocol, including ZigBee, Route Under MAC/6LoWPAN, and RF4CE. It uses a reverse polarity SMA connector (RP-SMA) for an external antenna. This allows the user to use nearly any existing 2.4 GHz antenna with it. The Zigduino runs on 3.3V, but all I/O pins are 5V compatible.

Pictured below is a production Zigduino kit with all components:

Thankfully all that SMD word is done for you. The prize units will have the headers and sockets already soldered (by me!). The Zigduino specifications include (from the website):

Microcontroller	Atmega128RFA1
Operating Voltage	3.3V
Input Voltage (recommended)	7-18V
Input Voltage (maximum)	6-30V (transients to -20V and +60V)
Digital I/O Pins	14 + 3 auxiliary
PWM Output Pins	6
Analog Input Pins	6 (0-1.8V)
I/O Protection	±30V transient
	-2.5V to +5.8V continuous
DC Current per I/O Pin	20 mA
DC Current for 5V Pin	250 mA
DC Current for 3.3V Pin	200 mA
Flash Memory	128 KB of which 2 KB is used by the bootloader
SRAM	16 KB
EEPROM	4 KB
Clock Speed	16 MHz
RF transmit power	+3.5 dBm
Receiver sensitivity	-100 dB
Antenna gain	2 dBi
Current Draw	30 mA (transmitting, USB, no I/O connections)
	15 mA (transmitting, no USB, no I/O connections)
	6 mA (radio off, no USB, no I/O connections)
	250 μA (sleep)

Compatibility

• Compatible with any shield that supports 3.3V logic
• Compatible with existing Arduino libraries that do not use hard-coded pin definitions
• Compatible with Arduino IDE with updated compiler, avr-gcc-4.3.3 or later.

Software

• Ported bootloader and Arduino core libraries, on Github.
  
• IEEE 802.15.4 MAC, from Atmel
• ZMAC, a compatibility layer to allow the use of Atmel’s MAC from inside the Arduino environment, from ManiacBug
• BitCloud, Atmel’s ZigBee PRO implementation

Power

The Zigduino can be powered through the USB connection or with an external power supply. The power source with the highest voltage is selected automatically.

External power can be supplied via a wall wart or a battery. It can be connected with a 2.1mm center-positive plug inserted into the power jack. Alternately, external power can be connected through the GND and VIN pins of the POWER header.

The board will operate correctly on an input voltage between 6V and 30V. It will survive transients as large as -20V or +60V. However, higher supply voltages may cause excessive heat dissipation at higher current draws. The input voltage regulator has integral overtemperature protection, so you can’t permanently damage the board this way. However, the board may not work correctly under these circumstances.

The power pins are as follows:

• VIN – The input voltage to the Arduino board when it is running from external power, i.e. not USB bus power.
• 5V – The regulated 5V used to power 5V components on the board and external 5V shields. It comes either from the USB or from the VIN via the 5V regulator. Maximum current draw is 250 mA.
• 3V3 – The regulated 3.3V supply that powers the microcontroller. It is derived from the 5V bus via a second regulator. Maximum current draw is 200 mA.
• GND – Ground pins.

Memory

The ATmega128RFA1 has 128 KB of flash memory, of which 2 KB is occupied by the bootloader. It also has 16 KB of SRAM (the most of any Arduino-compatible board) and 4 KB of EEPROM, which can be accessed through the EEPROM library.

Input and Output

Each of the 14 digital pins of the Zigduino can be used as an input or output, using pinMode(), digitalWrite(), and digitalRead(). Each pin operates at 3.3V and can source or sink 10 mA. Each also has an internal pullup, which is disabled by default. Each pin is protected against ±30V spikes and can tolerate continuous 5V input.

The six analog input pins, labeled A0 – A5, are likewise protected against ±30V spikes and can tolerate continuous 5V input. Each provides 10 bits of resolution and measures 0 – 1.8V. It is possible to change to a lower top voltage through use of the AREF pin and the analogReference() function.

A key design goal of the Zigduino is maintaining compatibility with existing shields to the greatest extent possible. The ATmega128RFA1′s peripherals are arranged slightly differently than the corresponding peripherals on the ATmega328 used in the stock Arduino. Therefore, in order to provide the desired shield compatibility, there are three solder jumpers provided on the back of the board. They function as follows:

• Digital pin 11 can be set as either SPI MOSI or a PWM output. Neither option is selected as shipped. SPI MOSI is also available on the SPI connector at all times along with SCK and MISO.
• Analog pin 4 can be set as either A4 or I2C SDA. Neither option is selected as shipped. Both I2C pins are available on the I2C connector.
• Analog pin 5 can be set as either A4 or I2C SCL. Neither option is selected as shipped. Both I2C pins are available on the I2C connector.

The following additional special functions are available:

• Serial: 0 (RX) and 1 (TX) – Used to transmit and receive TTL serial data. These pins are connected to the corresponding pins on the FTDI USB interface chip.
• PWM: 3, 5, 6, 9, 10, and 11 – Provides 8-bit PWM output with the analogWrite() function. Pin 11 must be selected for PWM operation with the solder jumper on the back of the board.
• SPI: 11 (MOSI), 12 (MISO), 13 (SCK) – These pins support SPI communications using the SPI library. Pin 11 must be selected for SPI operation with the solder jumper on the back, or SPI must be accessed with the SPI connector.
• LED: 13 – This is the built-in LED on digital pin 13. When the pin is high, the LED is on.
• External Interrupts: 2, 3, 6, and 7 – These pins can be configured to trigger and interrupt on a low value, high value, or an edge. See the attachInterrupt() function for details. The two I2C pins can also be used as interrupts.
• I2C: A4 (SDA) and A5 (SCL) – These pins support I2C communications using the Wire library. They must be selected for I2C operation with the jumpers on the back or I2C must be accessed through the I2C connector. They can also be configured as interrupts.

This is one very capable Arduino-compatible board and sure to find many uses. For updates and new ideas consider following the Logos Electromechanical blog page.  Furthermore associated Zigduino files can be found on Github.

*** Second prize is the assembled demonstration LoL Shield! from Little Bird Electronics ***

When too many LEDs just aren’t enough – the LoL Shield comes to the rescue. As recently reviewed, the Lol Shield allows all sorts of animations from a single blinking LED to complete animations, your imagination will run wild with this baby:

*** *** How to Enter *** *** 

This month the method of entry will be different to the usual treasure hunt of questions and answers. Instead, in thirty words or less explain what you would do with the Zigduinos if you received them. Use your imagination and have some fun – perhaps try your hand at Haiku or some nerdy poetry.

Email your submission along with your name, email address and postal address to competition at tronixstuff dot com with the subject heading September. Entries will be accepted until 01/10/2011 0005h GMT.

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

• 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;
• Prizes will be delivered via Australia Post domestic or regular international air mail;
• 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;
• Incomplete entries will be rejected;
• Prizes carry no warranty nor guarantee – and are to be used or abused at entirely your own risk;
• Entries will be accepted until 0005h GMT on 1st October 2011.

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.