Posts | Comments

Planet Arduino

Archive for the ‘freetronics’ Category

Nov
09

Project – LED Cube Spectrum Analyzer

analyzer, arduino, com-10468, cube, CUBE4, freetronics, kit, LED, MSGEQ7, project, projects, RGB, RGB LED, spectrum, tronixstuff, tutorial Commenti disabilitati su Project – LED Cube Spectrum Analyzer 

Introduction

A few weeks ago I was asked about creating a musical-effect display with an RGB LED cube kit from our friends over at Freetronics, and with a little work this was certainly possible using the MSGEQ7 spectrum analyzer IC. In this project we’ll create a small add-on PCB containing the spectrum analyzer circuit and show how it can drive the RGB LED cube kit.

Freetronics CUBE4 RGB LED cube kit

Assumed knowledge

To save repeating myself, please familiarise yourself with the MSGEQ7 spectrum analyzer IC in Chapter 48 of our Arduino tutorials. And learn more about the LED cube from our review and the product page.

You can get the bare MSGEQ7 ICs from Sparkfun and the other usual suspects. It never hurts to have a spare one, so order two and matching IC sockets. Finally you should be able to translate a simple circuit to prototyping board.

The circuit

The LED cube already has an Arduino Leonardo-compatible built in to the main PCB, so all you need to do is build a small circuit that contains the spectrum analyzer which connects to the I/O pins on the cube PCB and also has audio input and output connections. First, consider the schematic:

MSGEQ7 CUBE4 spectrum analyser schematic

For the purposes of this project our spectrum analyzer will only display the results from one channel of audio – if you want stereo, you’ll need two! And note that the strobe, reset and DCOUT pins on the MSGEQ7 are labelled with the connections to the cube PCB. Furthermore the pinouts for the MSGEQ7 don’t match the physical reality – here are the pinouts from the MSGEQ7 data sheet (.pdf):

MSGEQ7 pinouts

The circuit itself will be quite small and fit on a small amount of stripboard or veroboard. There is plenty of room underneath the cube to fit the circuit if so desired:

MSGEQ7 LED cube

With a few moments you should be able to trace out your circuit to match the board type you have, remember to double-check before soldering. You will also need to connect the audio in point after the 1000 pF capacitor to a source of audio, and also pass it through so you can connect powered speakers, headphones, etc.

One method of doing so would be to cut up a male-female audio extension lead, and connect the shield to the GND of the circuit, and the signal line to the audio input on the circuit. Or if you have the parts handy and some shielded cable, just make your own input and output leads:

MSGEQ7 input output leads

Be sure to test for shorts between the signal and shield before soldering to the circuit board. When finished, you should have something neat that you can hide under the cube or elsewhere:

MSGEQ7 RGB cube LED spectrum analyzer board

Double-check your soldering for shorts and your board plan, then fit to the cube along with the audio source and speakers (etc).

Arduino Sketch

The sketch has two main functions – the first is to capture the levels from the MSGEQ7 and put the values for each frequency band into an array, and the second function is to turn on LEDs that represent the level for each band. If you’ve been paying attention you may be wondering how we can represent seven frequency bands with a 4x4x4 LED cube. Simple – by rotating the cube 45 degrees you can see seven vertical columns of LEDs:

MSGEQ7 LED cube spectrum analyzer columns

So when looking from the angle as shown above, you have seven vertical columns, each with four levels of LEDs. Thus the strength of each frequency can be broken down into four levels, and then the appropriate LEDs turned on.

After this is done for each band, all the LEDs are turned off and the process repeats. For the sake of simplicity I’ve used the cube’s Arduino library to activate the LEDs, which also makes the sketch easier to fathom. The first example sketch only uses one colour:

// Freetronics CUBE4: and MSGEQ7 spectrum analyser
// MSGEQ7 strobe on A4, reset on D5, signal into A0

#include "SPI.h"
#include "Cube.h"
Cube cube;

int res = 5; // reset pins on D5
int left[7]; // store band values in these arrays
int band;

void setup()
{
  pinMode(res, OUTPUT); // reset
  pinMode(A4, OUTPUT); // strobe
  digitalWrite(res,LOW); 
  digitalWrite(A4,HIGH); 
  cube.begin(-1, 115200);
  Serial.begin(9600);
}

void readMSGEQ7()
// Function to read 7 band equalizers
{
  digitalWrite(res, HIGH);
  digitalWrite(res, LOW);
  for(band=0; band <7; band++)
  {
    digitalWrite(A4,LOW); // strobe pin on the shield - kicks the IC up to the next band 
    delayMicroseconds(30); // 
    left[band] = analogRead(0); // store band reading
    digitalWrite(A4,HIGH); 
  }
}

void loop()
{
  readMSGEQ7();

  for (band = 0; band < 7; band++)
  {
    // div each band strength into four layers, each band then one of the odd diagonals 

    // band one ~ 63 Hz
    if (left[0]>=768) { 
      cube.set(3,3,3, BLUE); 
    } 
    else       
      if (left[0]>=512) { 
      cube.set(3,3,2, BLUE); 
    } 
    else   
      if (left[0]>=256) { 
      cube.set(3,3,1, BLUE); 
    } 
    else       
      if (left[0]>=0) { 
      cube.set(3,3,0, BLUE); 
    } 

    // band two ~ 160 Hz
    if (left[1]>=768) 
    { 
      cube.set(3,2,3, BLUE); 
      cube.set(2,3,3, BLUE);      
    }  
    else
      if (left[1]>=512) 
      { 
        cube.set(3,2,2, BLUE); 
        cube.set(2,3,2, BLUE);      
      } 
      else   
        if (left[1]>=256) 
      { 
        cube.set(3,2,1, BLUE); 
        cube.set(2,3,1, BLUE);      
      } 
      else   
        if (left[1]>=0) 
      { 
        cube.set(3,2,0, BLUE); 
        cube.set(2,3,0, BLUE);      
      } 

    // band three ~ 400 Hz
    if (left[2]>=768) 
    { 
      cube.set(3,1,3, BLUE); 
      cube.set(2,2,3, BLUE);      
      cube.set(1,3,3, BLUE);            
    }  
    else
      if (left[2]>=512) 
      { 
        cube.set(3,1,2, BLUE); 
        cube.set(2,2,2, BLUE);      
        cube.set(1,3,2, BLUE);            
      } 
      else   
        if (left[2]>=256) 
      { 
        cube.set(3,1,1, BLUE); 
        cube.set(2,2,1, BLUE);      
        cube.set(1,3,1, BLUE);            
      } 
      else   
        if (left[2]>=0) 
      { 
        cube.set(3,1,0, BLUE); 
        cube.set(2,2,0, BLUE);      
        cube.set(1,3,0, BLUE);            
      } 

    // band four ~ 1 kHz
    if (left[3]>=768) 
    { 
      cube.set(3,0,3, BLUE); 
      cube.set(2,1,3, BLUE);      
      cube.set(1,2,3, BLUE);            
      cube.set(0,3,3, BLUE);                  
    }  
    else
      if (left[3]>=512) 
      { 
        cube.set(3,0,2, BLUE); 
        cube.set(2,1,2, BLUE);      
        cube.set(1,2,2, BLUE);            
        cube.set(0,3,2, BLUE);                        
      } 
      else   
        if (left[3]>=256) 
      { 
        cube.set(3,0,1, BLUE); 
        cube.set(2,1,1, BLUE);      
        cube.set(1,2,1, BLUE);      
        cube.set(0,3,1, BLUE);                        
      } 
      else   
        if (left[3]>=0) 
      { 
        cube.set(3,0,0, BLUE); 
        cube.set(2,1,0, BLUE);      
        cube.set(1,2,0, BLUE);            
        cube.set(0,3,0, BLUE);                        
      } 

    // band five  ~ 2.5 kHz
    if (left[4]>=768) 
    { 
      cube.set(2,0,3, BLUE); 
      cube.set(1,1,3, BLUE);      
      cube.set(0,2,3, BLUE);            
    }  
    else
      if (left[4]>=512) 
      { 
        cube.set(2,0,2, BLUE); 
        cube.set(1,1,2, BLUE);      
        cube.set(0,2,2, BLUE);            
      } 
      else   
        if (left[4]>=256) 
      { 
        cube.set(2,0,1, BLUE); 
        cube.set(1,1,1, BLUE);      
        cube.set(0,2,1, BLUE);      
      } 
      else   
        if (left[4]>=0) 
      { 
        cube.set(2,0,0, BLUE); 
        cube.set(1,1,0, BLUE);      
        cube.set(0,2,0, BLUE);            
      } 

    // band six   ~ 6.25 kHz
    if (left[5]>=768) 
    { 
      cube.set(1,0,3, BLUE); 
      cube.set(0,1,3, BLUE);      
    }  
    else
      if (left[5]>=512) 
      { 
        cube.set(1,0,2, BLUE); 
        cube.set(0,1,2, BLUE);      
      } 
      else   
        if (left[5]>=256) 
      { 
        cube.set(1,0,1, BLUE); 
        cube.set(0,1,1, BLUE);      
      } 
      else   
        if (left[5]>=0) 
      { 
        cube.set(1,0,0, BLUE); 
        cube.set(0,1,0, BLUE);      
      } 

    // band seven  ~ 16 kHz
    if (left[6]>=768) 
    { 
      cube.set(0,0,3, BLUE); 
    }  
    else
      if (left[6]>=512) 
      { 
        cube.set(0,0,2, BLUE); 
      } 
      else   
        if (left[6]>=256) 
      { 
        cube.set(0,0,1, BLUE); 
      } 
      else   
        if (left[6]>=0) 
      { 
        cube.set(0,0,0, BLUE); 
      } 
  }
  // now clear the CUBE, or if that's too slow - repeat the process but turn LEDs off
  cube.all(BLACK);
}

… and a quick video demonstration:

For a second example, we’ve used various colours:

// Freetronics CUBE4: and MSGEQ7 spectrum analyser
// MSGEQ7 strobe on A4, reset on D5, signal into A0
// now in colour!

#include "SPI.h"
#include "Cube.h"
Cube cube;

int res = 5; // reset pins on D5
int left[7]; // store band values in these arrays
int band;
int additional=0;

void setup()
{
  pinMode(res, OUTPUT); // reset
  pinMode(A4, OUTPUT); // strobe
  digitalWrite(res,LOW); 
  digitalWrite(A4,HIGH); 
  cube.begin(-1, 115200);
  Serial.begin(9600);
}

void readMSGEQ7()
// Function to read 7 band equalizers
{
  digitalWrite(res, HIGH);
  digitalWrite(res, LOW);
  for(band=0; band <7; band++)
  {
    digitalWrite(A4,LOW); // strobe pin on the shield - kicks the IC up to the next band 
    delayMicroseconds(30); // 
    left[band] = analogRead(0) + additional; // store band reading
    digitalWrite(A4,HIGH); 
  }
}

void loop()
{
  readMSGEQ7();

  for (band = 0; band < 7; band++)
  {
    // div each band strength into four layers, each band then one of the odd diagonals 

    // band one ~ 63 Hz
    if (left[0]>=768) { 
      cube.set(3,3,3, RED); 
    } 
    else       
      if (left[0]>=512) { 
      cube.set(3,3,2, YELLOW); 
    } 
    else   
      if (left[0]>=256) { 
      cube.set(3,3,1, YELLOW); 
    } 
    else       
      if (left[0]>=0) { 
      cube.set(3,3,0, BLUE); 
    } 

    // band two ~ 160 Hz
    if (left[1]>=768) 
    { 
      cube.set(3,2,3, RED); 
      cube.set(2,3,3, RED);      
    }  
    else
      if (left[1]>=512) 
      { 
        cube.set(3,2,2, YELLOW); 
        cube.set(2,3,2, YELLOW);      
      } 
      else   
        if (left[1]>=256) 
      { 
        cube.set(3,2,1, YELLOW); 
        cube.set(2,3,1, YELLOW);      
      } 
      else   
        if (left[1]>=0) 
      { 
        cube.set(3,2,0, BLUE); 
        cube.set(2,3,0, BLUE);      
      } 

    // band three ~ 400 Hz
    if (left[2]>=768) 
    { 
      cube.set(3,1,3, RED); 
      cube.set(2,2,3, RED);      
      cube.set(1,3,3, RED);            
    }  
    else
      if (left[2]>=512) 
      { 
        cube.set(3,1,2, YELLOW); 
        cube.set(2,2,2, YELLOW);      
        cube.set(1,3,2, YELLOW);            
      } 
      else   
        if (left[2]>=256) 
      { 
        cube.set(3,1,1, YELLOW); 
        cube.set(2,2,1, YELLOW);      
        cube.set(1,3,1, YELLOW);            
      } 
      else   
        if (left[2]>=0) 
      { 
        cube.set(3,1,0, BLUE); 
        cube.set(2,2,0, BLUE);      
        cube.set(1,3,0, BLUE);            
      } 

    // band four ~ 1 kHz
    if (left[3]>=768) 
    { 
      cube.set(3,0,3, RED); 
      cube.set(2,1,3, RED);      
      cube.set(1,2,3, RED);            
      cube.set(0,3,3, RED);                  
    }  
    else
      if (left[3]>=512) 
      { 
        cube.set(3,0,2, YELLOW); 
        cube.set(2,1,2, YELLOW);      
        cube.set(1,2,2, YELLOW);            
        cube.set(0,3,2, YELLOW);                        
      } 
      else   
        if (left[3]>=256) 
      { 
        cube.set(3,0,1, YELLOW); 
        cube.set(2,1,1, YELLOW);      
        cube.set(1,2,1, YELLOW);      
        cube.set(0,3,1, YELLOW);                        
      } 
      else   
        if (left[3]>=0) 
      { 
        cube.set(3,0,0, BLUE); 
        cube.set(2,1,0, BLUE);      
        cube.set(1,2,0, BLUE);            
        cube.set(0,3,0, BLUE);                        
      } 

    // band five  ~ 2.5 kHz
    if (left[4]>=768) 
    { 
      cube.set(2,0,3, RED); 
      cube.set(1,1,3, RED);      
      cube.set(0,2,3, RED);            
    }  
    else
      if (left[4]>=512) 
      { 
        cube.set(2,0,2, YELLOW); 
        cube.set(1,1,2, YELLOW);      
        cube.set(0,2,2, YELLOW);            
      } 
      else   
        if (left[4]>=256) 
      { 
        cube.set(2,0,1, YELLOW); 
        cube.set(1,1,1, YELLOW);      
        cube.set(0,2,1, YELLOW);      
      } 
      else   
        if (left[4]>=0) 
      { 
        cube.set(2,0,0, BLUE); 
        cube.set(1,1,0, BLUE);      
        cube.set(0,2,0, BLUE);            
      } 

    // band six   ~ 6.25 kHz
    if (left[5]>=768) 
    { 
      cube.set(1,0,3, RED); 
      cube.set(0,1,3, RED);      
    }  
    else
      if (left[5]>=512) 
      { 
        cube.set(1,0,2, YELLOW); 
        cube.set(0,1,2, YELLOW);      
      } 
      else   
        if (left[5]>=256) 
      { 
        cube.set(1,0,1, YELLOW); 
        cube.set(0,1,1, YELLOW);      
      } 
      else   
        if (left[5]>=0) 
      { 
        cube.set(1,0,0, BLUE); 
        cube.set(0,1,0, BLUE);      
      } 

    // band seven  ~ 16 kHz
    if (left[6]>=768) 
    { 
      cube.set(0,0,3, RED); 
    }  
    else
      if (left[6]>=512) 
      { 
        cube.set(0,0,2, YELLOW); 
      } 
      else   
        if (left[6]>=256) 
      { 
        cube.set(0,0,1, YELLOW); 
      } 
      else   
        if (left[6]>=0) 
      { 
        cube.set(0,0,0, BLUE); 
      } 
  }
  // now clear the CUBE, or if that's too slow - repeat the process but turn LEDs off
  cube.all(BLACK);
}

… and the second video demonstration:

A little bit of noise comes through into the spectrum analyzer, most likely due to the fact that the entire thing is unshielded. The previous prototype used the Arduino shield from the tutorial which didn’t have this problem, so if you’re keen perhaps make your own custom PCB for this project.

Conclusion

Well that was something different and I hope you enjoyed it, and can find use for the circuit. That MSGEQ7 is a handy IC and with some imagination you can create a variety of musically-influenced displays. And while you’re here – are you interested in learning more about Arduino? Then order my new book “Arduino Workshop” from No Starch Press.

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

The post Project – LED Cube Spectrum Analyzer appeared first on tronixstuff.

Ott
24

Freetronics OLED Display Competition Winner

competition, freetronics, tronixstuff Commenti disabilitati su Freetronics OLED Display Competition Winner 

In September we published a review of the new Freetronics OLED Display module for Arduino and Raspberry Pi, and inside that review was the details for a simple competition – send in a postcard to go in the draw for a free OLED display. Today marks the end of the competition, so we’ve put all the cards in a box, shuffled them around a bit and selected one winner:

postcard_OLED_winner

Congratulations to Jorge from Portugal. Thanks to all those who entered, and for the curious here are the submitted cards:

postcards_OLED_all

Personally I’d like to thank all those who enjoyed the spirit of the competition and sent in a card, and of course Freetronics for the OLED Display:

freetronics OLED

We hope to run more competitions in the future and also offer product discounts for our readers – so be sure to read all of a post when they appear. And if you made it this far – check out my new book “Arduino Workshop” from No Starch Press.

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

 

The post Freetronics OLED Display Competition Winner appeared first on tronixstuff.

Set
25

Review – Freetronics 128×128 Pixel Colour OLED Module

arduino, color, display, freetronics, LCD, OLED, product review, Raspberry Pi, review, tronixstuff, tutorial Commenti disabilitati su Review – Freetronics 128×128 Pixel Colour OLED Module 

Introduction

Time for another review, and in this instalment we have the new 128×128 Pixel OLED Module from Freetronics. It’s been a while since we’ve had a full-colour graphic display to experiment with, and this one doesn’t disappoint. Unlike other displays such as LCD, this one uses OLED – “Organic Light-Emitting Diode” technology.

OLEDs allow for a faster refresh rate, and to the naked eye has a great amount of colour contrast. Furthermore the viewing angles are excellent, you can clearly read the display from almost any angle, for example:

freetronics OLED display bottom view

freetronics OLED display side

However they can suffer from burn-in from extended display of the same thing so that does need to be taken into account. Nevertheless they provide an inexpensive and easy-to-use method of displaying colour text, graphics and even video from a variety of development boards. Finally – there is also a microSD socket for data logging, image storage or other uses. However back to the review unit. It arrives in typical retail packaging:

freetronics OLED display

and includes the OLED display itself, a nifty reusable parts tray/storage box, and two buttons. The display has a resolution of 128 x 128 pixels and has a square display area with a diagonal size of 38.1 mm. The unit itself is quite compact:

freetronics OLED display front

freetronics_OLED_display_rear

The display is easily mounted using the holes on the left and right-hand side of the display. The designers have also allowed space for an LED, current-limiting resistor and button on each side, for user input or gaming – perfect for the  included buttons. However this section of the PCB is also scored-off so you can remove them if required. Using the OLED isn’t difficult, and tutorials have been provided for both Arduino and Raspberry Pi users.

Using with Arduino

After installing the Arduino library, it’s a simple matter of running some jumper wires from the Arduino or compatible board to the display – explained in detail with the “Quickstart” guide. Normally I would would explain how to use the display myself, however in this instance a full guide has been published which explains how to display text of various colours, graphics, displaying images stored on a microSD card and more. Finally there’s some interesting demonstration sketches included with the library. For example, displaying large amounts of text:

… the variety of fonts available:

freetronics OLED font demonstration

… and for those interested in monitoring changing data types, a very neat ECG-style of sketch:

… and the mandatory rotating cube from a Freetronics forum member:

Using with Raspberry Pi

For users of this popular single-board computer, there’s a great tutorial and some example videos available on the Freetronics website for your consideration, such as the following video clip playback:

Support

Along with the Arduino and Raspberry Pi tutorials, there’s also the Freetronics support forum where members have been experimenting with accelerated drivers, demonstrations and more.

Competition!

For a chance to win your own OLED display, send a postcard with your email address clearly printed on the back to:

OLED Competition, PO Box 5435 Clayton 3168 Australia. 

Cards must be received by 24/10/2013. One card will then be selected at random and the winner will be sent one Freetronics OLED Display. Prize will be delivered by Australia Post standard air mail. We’re not responsible for customs or import duties, VAT, GST, import duty, postage delays, non-delivery or whatever walls your country puts up against receiving inbound mail.

Conclusion

Compared to previous colour LCD units used in the past, OLED technology is a great improvement – and demonstrated very well with this unit. Furthermore you get the whole package – anyone call sell you a display, however Freetronics also have the support, tutorials, drivers and backup missing from other retailers. So if you need a colour display, check it out.

And for more detail, full-sized images from this article can be found on flickr. And if you’re interested in learning more about Arduino, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop” from No Starch Press.

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

[Note - OLED display was a promotional consideration from Freetronics]

The post Review – Freetronics 128×128 Pixel Colour OLED Module appeared first on tronixstuff.

Ago
28

Initial Review – Goldilocks Arduino-compatible with ATmega1284P

arduino, atmega1284p, atmel, board, compatible, freetronics, goldilocks, part review, review, tronixstuff Commenti disabilitati su Initial Review – Goldilocks Arduino-compatible with ATmega1284P 

Introduction

In March this year we discussed a project by Phillip Stevens to crowd-fund an Arduino-compatible board with an ATmega1284p microcontroller – the “Goldilocks”. After being funded at a rapid rate, and subjected to some community feedback – the boards have now been manufactured and delivered to those who pledged. If you missed out – there’s some more available for direct sales. We ordered five and now have them for the subject of this review – and two to give away. So let’s examine the board and see what’s new.

What is it?

After hitting the limits of the Arduino Uno with respect to SRAM, CPU speed and not wanting to lose compatibility with existing projects by changing platforms, Philip decided to shift the MCU up to the ATmega1284P. This offers eight times the SRAM, four times the flash memory and EEPROM – and is also clocked at 20 MHz instead of the usual 16 MHz on Unos, etc. After the original design was announced, it was the victim of some pretty heavy feature-creep – however with Freetronics as the manufacturing partner the final result is a nicely-finished product:

freetronics goldilocks

Now let’s rip open the packaging and examine the board in greater detail. From the images below you can get the gist of things… starting with the top you can see the ATmega1284P next to the microSD card socket. There’s a JTAG connector for the 1284P on its left – and below that a 32.768 kHz crystal for RTC use. And like other Freetronics boards a large prototyping area has been squeezed in below pins D0~7 that also has the power and I2C lines at the edge. Furthermore note that all I/O pins are brought out to separate holes in alignment with the header sockets. And my favourite – a switch-mode power supply circuit that can offer up to 2A of current – great for GSM shields.

freetronics goldilocks top

Another point of interest is the ATmega32U2 microcontroller which is for USB duties – however it can be used as a separate “board” on its own, with a separate reset button, ICSP breakout and the ports are broken out logically:

freetronics goldilocks atmega32u2

Furthermore the 32U2′s SPI bus can be wired over to the main 1284P to allow communication between the two – simply by bridging the provided pads on the PCB you can join them. Also on the bottom you can see how each I/O pin can be disconnected from the I/O areas and thus diverted if necessary. It really is a testament to the design that so much of the board is customisable, and this attention to detail makes it stand apart from the usual Arduino-compatibles out there.

freetronics goldilocks bottom

One thing that did strike me was the retina-burning intensity of the onboard LEDs – however you can disable them by cutting the provided track on the PCB. For a complete explanation of the hardware side of things, check out the user guide.

Using the Goldilocks

One of the main goals was to be Arduino Uno R3-compatible, and from initial examination this is certainly the case. However there are a couple of differences, which you can find out more about in the user guide. This is not the first board for an Arduino user, but something chosen after getting some experience. Installation was very easy, it should be plug-and-play for the non-Windows crowd. However if you’re part of the silent majority of Windows users then the required U2duino Programmer.inf file for the Device Manager will be found in the production_firmware folder of the software download available on the product page. Furthermore no matter your OS – don’t forget to install the Arduino IDE Goldilocks board profile.

Before getting too excited and uploading your sketches, you can examine the the ATmega1284p bootloader monitor which allows for memory dumps, port testing, and more. Simply connect up your board, load the Arduino IDE, select the board and COM: port then open the Serial Monitor. By sending “!!!” after a board reset, a simple menu appears – which is shown in the following video:

Now for a quick speed test. We’ll use a sketch written by Steve Curd from the Arduino forum. It calculates Newton Approximation for pi using an infinite series:

// Pi_2 by Steve Curd // December 2012
// This program approximates pi utilizing the Newton's approximation.  It quickly
// converges on the first 5-6 digits of precision, but converges verrrry slowly
// after that.  For example, it takes over a million iterations to get to 7-8
// significant digits.

#define ITERATIONS 100000L    // number of iterations
#define FLASH 1000            // blink LED every 1000 iterations

void setup() 
{
  pinMode(13, OUTPUT);        // set the LED up to blink every 1000 iterations
  Serial.begin(57600);
}

void loop() 
{
  unsigned long start, time;
  unsigned long niter=ITERATIONS;
  int LEDcounter = 0;
  boolean alternate = false;
  unsigned long i, count=0;
  float x = 1.0;
  float temp, pi=1.0;
  Serial.print("Beginning ");
  Serial.print(niter);
  Serial.println(" iterations...");
  Serial.println();
  start = millis();  
  for ( i = 2; i < niter; i++) {
    x *= -1.0;
    pi += x / (2.0f*(float)i-1.0f);
    if (LEDcounter++ > FLASH) {
      LEDcounter = 0;
      if (alternate) {
        digitalWrite(13, HIGH);
        alternate = false;
      } else {
        digitalWrite(13, LOW);
        alternate = true;
      }
      temp = 40000000.0 * pi;
    }
  }
  time = millis() - start;
  pi = pi * 4.0;
  Serial.print("# of trials = ");
  Serial.println(niter);
  Serial.print("Estimate of pi = ");
  Serial.println(pi, 10);
  Serial.print("Time: "); Serial.print(time); Serial.println(" ms");
  delay(10000);
}

The Goldilocks was compared with a standard Arduino Uno, with the following results (click image to enlarge):

goldilocks Uno speed test

 As you can see from the results below, the Goldilocks theoretical extra 4 Mhz of speed is shown in the elapsed time between the two boards – 4433 ms for the Goldilocks vs. 5562 ms for the Uno, a 25.4% increase. Looking good. We’ll leave it for now – however for more information you can review the complete user manual, and also discuss Goldilocks in the Freetronics customer forum.

Competition

Two of our twitter followers will be randomly selected on the 14th of September, and will each receive one Goldilocks board. So follow us on @tronixstuff for a chance to win a board, and also keep up with news, new articles and items of interest. Board will be delivered by Australia Post standard air mail. We’re not responsible for customs or import duties, VAT, GST, import duty, postage delays, non-delivery or whatever walls your country puts up against receiving inbound mail.

Conclusion

The Goldilocks is the board that can solve many problems – especially when you’ve outgrown your Uno or similar board. We look forward to using it with larger projects that burn up SRAM and exploring the possibilities of using the two microcontrollers at once. There’s a whole bundle of potential – so congratulations to Phillip Stevens, Freetronics and all those who pledge to the funding and supported the project in general. And to join in – you can get your own from Freetronics. Full-sized images are on flickr. And if you made it this far – check out my new book “Arduino Workshop” from No Starch Press.

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

The post Initial Review – Goldilocks Arduino-compatible with ATmega1284P appeared first on tronixstuff.

Ago
14

Part review – Freetronics HBRIDGE motor driver shield for Arduino

A4954, allegro, arduino, dc, driver, eleven, freetronics, H-Bridge, HBRIDGE, motor, part review, review, Stepper, Stepper Motor, tronixstuff, tutorial Commenti disabilitati su Part review – Freetronics HBRIDGE motor driver shield for Arduino 

Introduction

Controlling motors with an Arduino is a fun and generally integral part of the learning process for most up-and-coming embedded electronics enthusiasts. Or quite simply, using motors is fun ’cause you can make robots, tanks and stuff that moves. And thanks to Freetronics we have their new HBRIDGE motor shield for Arduino to review, so let’s check it out and get some things moving with it.

Arriving in retail-friendly packaging, the HBRIDGE can be stored with the included reusable packaging, and also has a quick-start guide that explains the technical specifications and URLs for tutorials:

HBRIDGE

The shield is compatible with the latest R3-series Arduino boards including the Leonardo and of course the Freetronics Eleven board:

HBRIDGE shield Freetronics Eleven

Specifications

The HBRIDGE shield is based on the Allegro A4954 Dual Full-Bridge DMOS PWM Motor Driver. For the curious, you can download the data sheet (pdf). This allows very simple control of two DC motors with a maximum rating of 40V at 2A, or one bipolar stepper motor. Unlike other motor shields I’ve seen, the HBRIDGE has a jumper which allows the power supply for the motor shield to be fed into the Arduino’s Vin line – so if your motor power supply is under 12V DC you can also power the Arduino from the same supply. Or you can run the motors from the Arduino’s power supply – if you’re sure that you won’t exceed the current rating. Frankly the former would be a safer and this the preferable solution.

The motor(s) are controlled very simply via PWM and digital logic. You feed the A4954 a PWM signal from a digital output pin for motor speed, and also set two inputs with a combination of high/low to set the motor direction, and also put the motor controlled into coast or brake mode. However don’t panic, it’s really easy.

Using the shield

How easy? Let’s start with two DC motors. One example of this is the tank chassis used in Chapter 12 of my book “Arduino Workshop - A Hands-On Introduction with 65 Projects“:

arduino_workshop_tank

The chassis is pretty much a standard tank chassis with two DC motors that run from an internal 9V battery pack. Search the Internet for “Dagu Rover 5″ for something similar. Connection is a simple manner of feeding the power lines from the battery and the motor wires into the terminal block on the HBRIDGE shield.

Next, take note of two things. First – the slide switches below the jumpers. Using these you can select the maximum amount of current allowed to flow from the power supply to each motor. These can be handy to ensure your motor doesn’t burn out by drawing too much current in a stall situation, so you can set these to the appropriate setting for your motor – or if you’re happy there won’t be any issues just leave them both on 2A.

The second thing to note is the six jumpers above the switches. These control which digital pins on your Arduino are used to control the motor driver. Each motor channel requires two outputs and one PWM output. If you leave them all on, the Arduino pins used will be the ones listed next to each jumper, otherwise remove the jumpers and manually wire to the required output. For the purposes of our demonstration, we’ll leave all the jumpers in. A final word of warning is to be careful not to touch the A4954 controller IC after some use – it can become really hot … around 160 degrees Celsius. It’s the circled part in the image below:

A4954_controller_IC

So back to the DC motors. You have two digital outputs to set, and also a PWM signal to generate – for each channel. If you set the outputs to 1 and 0  - the motor spins in one direction. Use 0 and 1 to spin the other way. And the value of the PWM (0~255) determines the speed. So consider the following sketch:

// Freetronics HBridge shield demonstration

int motora1 = 4;
int motora2 = 7;
int motoraspeed = 6;
int motorb1 = 3;
int motorb2 = 2;
int motorbspeed = 5;

void setup()
{
  pinMode(motora1, OUTPUT);
  pinMode(motora2, OUTPUT);
  pinMode(motoraspeed, OUTPUT); 
  pinMode(motorb1, OUTPUT);
  pinMode(motorb2, OUTPUT);
  pinMode(motorbspeed, OUTPUT);  
  delay(5000); 
}

void allOff()
// turns both motors off
{
  digitalWrite(motora1, LOW);
  digitalWrite(motora2, LOW);
  digitalWrite(motoraspeed, LOW);
  digitalWrite(motorb1, LOW);
  digitalWrite(motorb2, LOW);
  digitalWrite(motorbspeed, LOW);  
}

void goForward(int speed)
{
  digitalWrite(motora1, HIGH);
  digitalWrite(motora2, LOW);
  digitalWrite(motoraspeed, speed);
  digitalWrite(motorb1, HIGH);
  digitalWrite(motorb2, LOW);
  digitalWrite(motorbspeed, speed);  
}

void goBackward(int speed)
{
  digitalWrite(motora1, LOW);
  digitalWrite(motora2, HIGH);
  digitalWrite(motoraspeed, speed);
  digitalWrite(motorb1, LOW);
  digitalWrite(motorb2, HIGH);
  digitalWrite(motorbspeed, speed); 
}

void turnRight(int speed)
{
  digitalWrite(motora1, LOW);
  digitalWrite(motora2, HIGH);
  digitalWrite(motoraspeed, speed);
  digitalWrite(motorb1, HIGH);
  digitalWrite(motorb2, LOW);
  digitalWrite(motorbspeed, speed); 
}

void turnLeft(int speed)
{
  digitalWrite(motora1, HIGH);
  digitalWrite(motora2, LOW);
  digitalWrite(motoraspeed, speed);
  digitalWrite(motorb1, LOW);
  digitalWrite(motorb2, HIGH);
  digitalWrite(motorbspeed, speed); 
}

void loop()
{
  goForward(255);
  delay(1000);
  turnLeft(200);
  delay(1000);
  goBackward(255);
  delay(1000);
  turnRight(200);
  delay(1000);
}

Instead of chasing the tank chassis with a camera, here it is on the bench:

Now to try out a stepper motor. You can control a bipolar motor with the HBRIDGE shield, and each coil (pole) is connected to a motor channel.

Hint – if you’re looking for a cheap source of stepper motors, check out discarded office equipment such as printers or photocopiers. 

For the demonstration, I’ve found a random stepper motor from a second-hand store and wired up each pole to a channel on the HBRIDGE shield – then run the Arduino stepper motor demonstration sketch by Tom Igoe:

/*
 Based on example by Tom Igoe included in Arduino IDE
 at File -> Examples -> Stepper -> stepper_oneRevolution

 Modified to suit pinouts of Freetronics HBridge Shield
*/

#include <Stepper.h>

const int stepsPerRevolution = 240;  // change this to fit the number of steps per revolution
                                     // for your motor

// initialize the stepper library using the default pins on the HBridge Shield:
Stepper myStepper(stepsPerRevolution, 4, 7, 3, 2);

void setup() {
  // set the speed at 200 rpm:
  myStepper.setSpeed(200);
  // initialize the serial port:
  Serial.begin(38400);
}

void loop() {
  // step one revolution  in one direction:
   Serial.println("clockwise");
  myStepper.step(stepsPerRevolution);
  delay(1000);

   // step one revolution in the other direction:
  Serial.println("counterclockwise");
  myStepper.step(-stepsPerRevolution);
  delay(1000); 
}

With the following results:

Considering it was a random stepper motor for which we didn’t have the specifications for – it’s always nice to have it work the first time! For more formal situations, ensure your stepper motor matches the power supply voltage and so on. Nevertheless it shows how easy it can be to control something that appears complex to some people, so enjoy experimenting with them if you can.

Competition

Thanks to Freetronics we have a shield to give away to one lucky participant. To enter, clearly print your email address on the back of a postcard and mail it to:

H-Bridge Competition, PO Box 5435 Clayton 3168 Australia.

Entries must be received by the 20th of  September 2013. One postcard will then be drawn at random, and the winner will receive one H-Bridge shield delivered by Australia Post standard air mail. One entry per person – duplicates will be destroyed. We’re not responsible for customs or import duties, VAT, GST, import duty, postage delays, non-delivery or whatever walls your country puts up against receiving inbound mail.

Conclusion

As demonstrated, the HBRIDGE shield “just works” – which is what you need when bringing motorised project ideas to life. The ability to limit current flow and also power the host board from the external supply is a great idea, and with the extra prototyping space on the shield you can also add extra circuitry without needing another protoshield. Very well done. For more information and to order, visit the Freetronics website. Full-sized images are on flickr. And if you made it this far – check out my new book “Arduino Workshop” from No Starch Press.

tronixstuff

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

Note – The motor shield used in this article was a promotional consideration supplied by Freetronics.

The post Part review – Freetronics HBRIDGE motor driver shield for Arduino appeared first on tronixstuff.

Ago
09

Introduction

If you’re awake and an Internet user, sooner or later  you’ll come across the concept of the “Internet of Things”. It is the goal of many people and organisations to have everything connected to everything for the exchange of data and the ability to control things. And as time marches on, more systems (or “platforms”) are appearing on the market. Some can be quite complex, and some are very easy to use – and this is where our interests lay. In the past we’ve examined the teleduino system, watched the rise of Ninja Blocks, and other connected devices like the lifx bulb and more.

However the purpose of this article is to demonstrate a new platform – XOBXOB (pronounced “zob-zob”) that gives users (and Arduino users in particular) a method of having remote devices connect with each other and be controlled over the Internet. At the time of writing XOBXOB is still in alpha stage, however you’re free to give it a go. So let’s do that now with Arduino.

Getting Started

You’ll need an Arduino and Ethernet shield – or a combination board such as a Freetronics EtherTen, or a WiFly board from Sparkfun. If you don’t have any Ethernet hardware there is a small application you can download that gives your USB-connected Arduino a link to the XOBXOB service. However before that, visit the XOBXOB homepage and register for an account. From there you can visit the dashboard which has your unique API key and a few controls:

XOBXOB dashboard

Now download the Arduino libraries and copy them into the usual location. If you don’t have an Ethernet shield, also get the “connector” application (available for all three OSs). The connector application is used after uploading the XOBXOB-enabled sketches to your Arduino and links it to the XOBXOB service.

Testing with exanples

Moving on, we’ve started with the basic LED control Ethernet sketch which is included in the XOBXOB library. It’s a fast way to check the system is working and your Internet connection is suitable. When using the examples for the first time (or any other XOBXOB sketch, don’t forget to enter your API key and Ethernet MAC address, for example:

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0x12, 0x01 };
String APIKey = "cc6zzzzz-0494-4cd7-98a6-62cf21aqqqqq";

We have the EtherTen connected to the ADSL and control via a cellular phone. It’s set to control digital pin 8 so after inserting an LED it worked first time:

The LED is simply turned on and off by using the ON/OFF panel on the XOBXOB dashboard, and then clicking “SET”. You can also click “GET” to retrieve the status of the digital output. The GET function is useful if more than one person is logged into the dashboard controlling what’s at the other end.

Now for some more fun with the other included example, which controls a MAX7219 LED display driver IC. We used one of the boards from the MAX7219 test a while back, which worked fine with the XOBXOB example in the Arduino library:

If this example doesn’t compile for you, remove the line:

#include <"avr/pgmspace.h">

Once operating, this example is surprisingly fun, and could be built into a small enclosure for a simple remote-messaging system.

Controlling your own projects

The functions are explained in the Arduino library guide, which you should download and review. Going back to the LED blink example, you can see how the sketch gets and checks for a new on/off message in the following code:

if (!lastResponseReceived && XOB.loadStreamedResponse()) {

    lastResponseReceived = true;

    String LED = XOB.getMessage("switch");
    if (LED == "\"ON\"") {
      digitalWrite (8, HIGH);
    } 
    else {
      digitalWrite (8, LOW);
    }

So instead of the digitalWrite() functions, you can insert whatever you want to happen when the ON/OFF button is used on the XOBXOB dashboard.  For example with the use of a Powerswitch Tail you could control a house light or other device from afar.

If you want to control more than one device from the dashboard, you need to create another XOB. This is done by entering the “advanced” dashboard and clicking “New”. After entering a name for the new XOB it will then appear in the drop-down list in either dashboard page. To then assign that XOB to a new device, it needs to be told to request that XOB by name in the Arduino sketch.

For example, if you created a new XOB called “garagelight” you need to insert the XOB name in the XOB.requestXOB() function in the sketch:

XOB.requestXOB("garagelight");

and then it will respond to the dashboard when required. Later on we’ll return to XOBXOB and examine how to upload information from a device to the dashboard, to allow remote monitoring of temperature and other data.

Conclusion

Experimenting with XOBXOB was a lot of fun, and much easier than originally planned. Although only in the beginning stages, I’m sure it can find a use with your hardware and a little imagination. Note that XOBXOB is still in alpha stage and not a finished product. For more information, visit hte XOBXOB website. And if you made it this far – check out my new book “Arduino Workshop” from No Starch Press.

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

The post Arduino and the XOBXOB IoT Platform appeared first on tronixstuff.

Ago
09

Introduction

If you’re awake and an Internet user, sooner or later  you’ll come across the concept of the “Internet of Things”. It is the goal of many people and organisations to have everything connected to everything for the exchange of data and the ability to control things. And as time marches on, more systems (or “platforms”) are appearing on the market. Some can be quite complex, and some are very easy to use – and this is where our interests lay. In the past we’ve examined the teleduino system, watched the rise of Ninja Blocks, and other connected devices like the lifx bulb and more.

However the purpose of this article is to demonstrate a new platform – XOBXOB (pronounced “zob-zob”) that gives users (and Arduino users in particular) a method of having remote devices connect with each other and be controlled over the Internet. At the time of writing XOBXOB is still in alpha stage, however you’re free to give it a go. So let’s do that now with Arduino.

Getting Started

You’ll need an Arduino and Ethernet shield – or a combination board such as a Freetronics EtherTen, or a WiFly board from Sparkfun. If you don’t have any Ethernet hardware there is a small application you can download that gives your USB-connected Arduino a link to the XOBXOB service. However before that, visit the XOBXOB homepage and register for an account. From there you can visit the dashboard which has your unique API key and a few controls:

XOBXOB dashboard

Now download the Arduino libraries and copy them into the usual location. If you don’t have an Ethernet shield, also get the “connector” application (available for all three OSs). The connector application is used after uploading the XOBXOB-enabled sketches to your Arduino and links it to the XOBXOB service.

Testing with exanples

Moving on, we’ve started with the basic LED control Ethernet sketch which is included in the XOBXOB library. It’s a fast way to check the system is working and your Internet connection is suitable. When using the examples for the first time (or any other XOBXOB sketch, don’t forget to enter your API key and Ethernet MAC address, for example:

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0x12, 0x01 };
String APIKey = "cc6zzzzz-0494-4cd7-98a6-62cf21aqqqqq";

We have the EtherTen connected to the ADSL and control via a cellular phone. It’s set to control digital pin 8 so after inserting an LED it worked first time:

The LED is simply turned on and off by using the ON/OFF panel on the XOBXOB dashboard, and then clicking “SET”. You can also click “GET” to retrieve the status of the digital output. The GET function is useful if more than one person is logged into the dashboard controlling what’s at the other end.

Now for some more fun with the other included example, which controls a MAX7219 LED display driver IC. We used one of the boards from the MAX7219 test a while back, which worked fine with the XOBXOB example in the Arduino library:

If this example doesn’t compile for you, remove the line:

#include <"avr/pgmspace.h">

Once operating, this example is surprisingly fun, and could be built into a small enclosure for a simple remote-messaging system.

Controlling your own projects

The functions are explained in the Arduino library guide, which you should download and review. Going back to the LED blink example, you can see how the sketch gets and checks for a new on/off message in the following code:

if (!lastResponseReceived && XOB.loadStreamedResponse()) {

    lastResponseReceived = true;

    String LED = XOB.getMessage("switch");
    if (LED == "\"ON\"") {
      digitalWrite (8, HIGH);
    } 
    else {
      digitalWrite (8, LOW);
    }

So instead of the digitalWrite() functions, you can insert whatever you want to happen when the ON/OFF button is used on the XOBXOB dashboard.  For example with the use of a Powerswitch Tail you could control a house light or other device from afar.

If you want to control more than one device from the dashboard, you need to create another XOB. This is done by entering the “advanced” dashboard and clicking “New”. After entering a name for the new XOB it will then appear in the drop-down list in either dashboard page. To then assign that XOB to a new device, it needs to be told to request that XOB by name in the Arduino sketch.

For example, if you created a new XOB called “garagelight” you need to insert the XOB name in the XOB.requestXOB() function in the sketch:

XOB.requestXOB("garagelight");

and then it will respond to the dashboard when required. Later on we’ll return to XOBXOB and examine how to upload information from a device to the dashboard, to allow remote monitoring of temperature and other data.

Conclusion

Experimenting with XOBXOB was a lot of fun, and much easier than originally planned. Although only in the beginning stages, I’m sure it can find a use with your hardware and a little imagination. Note that XOBXOB is still in alpha stage and not a finished product. For more information, visit hte XOBXOB website. And if you made it this far – check out my new book “Arduino Workshop” from No Starch Press.

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

The post Arduino and the XOBXOB IoT Platform appeared first on tronixstuff.

Ago
07

Freetronics CUBE4: RGB LED Cube Competition Winner

competition, freetronics, tronixstuff Commenti disabilitati su Freetronics CUBE4: RGB LED Cube Competition Winner 

In June we published a review of the Freetronics CUBE4: RGB LED Cube kit, and inside that review was the details for a simple competition – send in a postcard to go in the draw for a free kit. So today we’ve put all the cards in a box, shuffled them around a bit and selected one winner:

winnersmall

Thanks to all those who entered, and for the curious here are the submitted cards:

entrantssmall

Personally I’d like to thank all those who enjoyed the spirit of the competition and sent in a card. I’ve always wanted to visit Germany and from the look of the postcards, now Utah looks good as well. We’ll contact the winning participant by email.

We hope to run more competitions in the future and also offer product discounts for our readers – so be sure to read all of a post when they appear. And if you made it this far – check out my new book “Arduino Workshop” from No Starch Press.

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

 

The post Freetronics CUBE4: RGB LED Cube Competition Winner appeared first on tronixstuff.

Giu
11

Kit review – the Freetronics CUBE4: RGB LED Cube

4x4x4, arduino, argot, cube, freetronics, jaycar, kit, kit review, LED, leonardo, LeoStick, review, RGB, XC4274 Commenti disabilitati su Kit review – the Freetronics CUBE4: RGB LED Cube 

Introduction

LED cubes are a fascinating item, no matter where you come from the allure of blinking LEDs in various patterns is always attractive. And making your own is a fun challenge that most people can do after some experience with electronics hardware. However most people use single-colour LEDs, as wiring up RGB units triples the complexity of the circuit. Until now.

After much anticipation Freetronics have released their CUBE4 RGB LED cube kit – a simple to assemble and completely-customisable RGB LED cube:

cube4off

Unlike other cubes on the market, this one includes an on-board ATmega32u4 microcontroller with Arduino Leonardo-compatible bootloader and a microUSB socket (… and a lot more) – so you don’t need anything extra to get started. And this gives you many more options when you’re ready to expand. But first let’s put it together and then get it working. Furthermore, keep reading to find out how you can have a chance to win your own Cube4.

Assembly

Inside the box are all the parts needed for the kit, even a microUSB cable to power the Cube4 and also communicate with it:

parts

There’s 64 RGB LEDs in that bag, so get ready for some soldering. The base PCB is well laid out, labelled and gives you an idea for the expansion possibilities:

PCBtop

Plenty of room to add your own circuitry – and the bottom:

PCBbottom

As you can see in the image above, there’s an XBee-compatible pinout if you want to add communication via wirless serial link, plenty of prototyping space for your own additions and many other ports are brought out to open pads. There’s even a 5V supply pair to test LEDs, and a blue “power on” LED (which can be deactivated if necessary by cutting a track on the PCB).

The first job is to mount the LEDs on their plane PCBs – there are four, one for each horizontal plant. It’s very important to get the LEDs in the right way round, and there’s markers on the PCB that you can match up the longest leg of the LED with:

LEDinsertdirection

From experience I found it best to insert all the LEDs:

LEDsinserted

…and then do a final mass check of the alignment – which is easy if you hold the plane up to one side and compare the legs, for example:

checkLEDdirection

At this stage it’s a great idea to double-check your LED alignment. After a while you’ll have the LEDs soldered in and trimmed nicely:

LEDssoldered

The next step was getting the vertical sticks aligned in order to hold the LED planes (above). Each stick is for a particular spot on the PCB so check the label on the stick matches the hole on the PCB. It’s incredibly important to make sure you have them perfectly perpendicular to the PCB, so find something like a square-edge or card to help out:

alignstick

Once you have a row of sticks in you can start with a plane then insert a stick on the other side, for example:

firstplanerubberband

Note the use of the elastic band to hold things together – they really help. Then it’s a simple matter of adding the planes and holding it together with another band:

fourplanespresolder

… at which point you can do a final check that all the planes and sticks are inserted correctly. Then solder all the copper spots together and you’re done.

Don’t forget to turn the cube upside-down as there’s soldering to be done on the bottom of the planes as well:

solderupsidedownaswell

 Although it might look a little scary, the final assembly isn’t that difficult – just take your time so it’s right the first time. You can view the following video which describes the entire process:

Once you’re confident that all the soldering has been completed – double-check for joints that aren’t completely bridged with solder as they will affect the operation of the cube. Then you can plug in the USB cable and watch the preloaded test/demonstration sketch in action:

If all your LEDs are working, awesome. If not – check the soldering. If there’s still some rogues – check your individual LEDs. Some of you are probably thinking “well that isn’t too colourful” – the problem is the camera, not the Cube4. If you see it in real life, it’s much better.

Operation

There are two methods of controlling the Cube4. It is delivered with a preloaded sketch that runs the demonstration showed in the video above, and then accepts commands over a serial/USB connection. So you can simply plug it in, fire up a terminal program (or the Arduino IDE serial monitor) and send text commands to do various things. If you type “help ;” the syntax is returned which explains how you can do things (click image to enlarge):

helpscreen

This serial control mode allows control by any type of software that can write to a serial port. Furthermore any other external hardware that can create or introduce serial text can also control the Cube4. For example by mounting an XBee module underneath and linking it to the TX/RX lines gives you a wireless Cube4. By doing so you can control it with a Raspberry Pi or other system.

Furthermore the Cube4 is also an Arduino Leonardo-compatible board in the same way as a Freetronics LeoStick.  With the use of the Cube4 Arduino library you can then create your own sketches which can visualise data with very simple to use functions for the Cube4. There are some great example sketches with the library for some inspiration and fun. Over time I look forward to using the Cube4 in various ways, including adding an Electric Imp IoT device and making another clock (!).

Competition

Would you like the chance to win a Cube4? It’s easy. Clearly print your email address on a postcard, and mail it to:

CUBE4 Competition, PO Box 5435, Clayton 3168, Australia

Entries must be received by the 30th of  July 2013. One postcard will then be drawn at random, and the winner will receive one Cube4 delivered by Australia Post standard air mail. You can enter as many times as you like. We’re not responsible for customs or import duties, VAT, GST, postage delays, non-delivery or whatever walls your country puts up against receiving inbound mail.

More demonstrations

Check out this Argot IoT demonstration.

Conclusion

This is the most approachable RGB LED cube kit on the market, and also the easiest to use. You don’t need to understand programming to try it out – and if you do it’s incredibly versatile. A lot of work has gone into the library, API and hardware design so you’ve got an expandable tool and not just some blinking LEDs. For more information visit the Freetronics website.  Larger photos available on flickr. And if you made it this far – check out my new book “Arduino Workshop” from No Starch Press.

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


Giu
11

Kit review – the Freetronics CUBE4: RGB LED Cube

4x4x4, arduino, argot, cube, freetronics, jaycar, kit, kit review, LED, leonardo, LeoStick, review, RGB, XC4274 Commenti disabilitati su Kit review – the Freetronics CUBE4: RGB LED Cube 

Introduction

LED cubes are a fascinating item, no matter where you come from the allure of blinking LEDs in various patterns is always attractive. And making your own is a fun challenge that most people can do after some experience with electronics hardware. However most people use single-colour LEDs, as wiring up RGB units triples the complexity of the circuit. Until now.

After much anticipation Freetronics have released their CUBE4 RGB LED cube kit – a simple to assemble and completely-customisable RGB LED cube:

cube4off

Unlike other cubes on the market, this one includes an on-board ATmega32u4 microcontroller with Arduino Leonardo-compatible bootloader and a microUSB socket (… and a lot more) – so you don’t need anything extra to get started. And this gives you many more options when you’re ready to expand. But first let’s put it together and then get it working. Furthermore, keep reading to find out how you can have a chance to win your own Cube4.

Assembly

Inside the box are all the parts needed for the kit, even a microUSB cable to power the Cube4 and also communicate with it:

parts

There’s 64 RGB LEDs in that bag, so get ready for some soldering. The base PCB is well laid out, labelled and gives you an idea for the expansion possibilities:

PCBtop

Plenty of room to add your own circuitry – and the bottom:

PCBbottom

As you can see in the image above, there’s an XBee-compatible pinout if you want to add communication via wirless serial link, plenty of prototyping space for your own additions and many other ports are brought out to open pads. There’s even a 5V supply pair to test LEDs, and a blue “power on” LED (which can be deactivated if necessary by cutting a track on the PCB).

The first job is to mount the LEDs on their plane PCBs – there are four, one for each horizontal plant. It’s very important to get the LEDs in the right way round, and there’s markers on the PCB that you can match up the longest leg of the LED with:

LEDinsertdirection

From experience I found it best to insert all the LEDs:

LEDsinserted

…and then do a final mass check of the alignment – which is easy if you hold the plane up to one side and compare the legs, for example:

checkLEDdirection

At this stage it’s a great idea to double-check your LED alignment. After a while you’ll have the LEDs soldered in and trimmed nicely:

LEDssoldered

The next step was getting the vertical sticks aligned in order to hold the LED planes (above). Each stick is for a particular spot on the PCB so check the label on the stick matches the hole on the PCB. It’s incredibly important to make sure you have them perfectly perpendicular to the PCB, so find something like a square-edge or card to help out:

alignstick

Once you have a row of sticks in you can start with a plane then insert a stick on the other side, for example:

firstplanerubberband

Note the use of the elastic band to hold things together – they really help. Then it’s a simple matter of adding the planes and holding it together with another band:

fourplanespresolder

… at which point you can do a final check that all the planes and sticks are inserted correctly. Then solder all the copper spots together and you’re done.

Don’t forget to turn the cube upside-down as there’s soldering to be done on the bottom of the planes as well:

solderupsidedownaswell

 Although it might look a little scary, the final assembly isn’t that difficult – just take your time so it’s right the first time. You can view the following video which describes the entire process:

Once you’re confident that all the soldering has been completed – double-check for joints that aren’t completely bridged with solder as they will affect the operation of the cube. Then you can plug in the USB cable and watch the preloaded test/demonstration sketch in action:

If all your LEDs are working, awesome. If not – check the soldering. If there’s still some rogues – check your individual LEDs. Some of you are probably thinking “well that isn’t too colourful” – the problem is the camera, not the Cube4. If you see it in real life, it’s much better.

Operation

There are two methods of controlling the Cube4. It is delivered with a preloaded sketch that runs the demonstration showed in the video above, and then accepts commands over a serial/USB connection. So you can simply plug it in, fire up a terminal program (or the Arduino IDE serial monitor) and send text commands to do various things. If you type “help ;” the syntax is returned which explains how you can do things:

helpscreen

This serial control mode allows control by any type of software that can write to a serial port. Furthermore any other external hardware that can create or introduce serial text can also control the Cube4. For example by mounting an XBee module underneath and linking it to the TX/RX lines gives you a wireless Cube4. By doing so you can control it with a Raspberry Pi or other system.

Furthermore the Cube4 is also an Arduino Leonardo-compatible board in the same way as a Freetronics LeoStick.  With the use of the Cube4 Arduino library you can then create your own sketches which can visualise data with very simple to use functions for the Cube4. There are some great example sketches with the library for some inspiration and fun. Over time I look forward to using the Cube4 in various ways, including adding an Electric Imp IoT device and making another clock (!).

More demonstrations

Check out this Argot IoT demonstration.

Conclusion

This is the most approachable RGB LED cube kit on the market, and also the easiest to use. You don’t need to understand programming to try it out – and if you do it’s incredibly versatile. A lot of work has gone into the library, API and hardware design so you’ve got an expandable tool and not just some blinking LEDs. For more information visit the Freetronics website.  Larger photos available on flickr. And if you made it this far – check out my new book “Arduino Workshop” from No Starch Press.

LEDborder

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

The post Kit review – the Freetronics CUBE4: RGB LED Cube appeared first on tronixstuff.



  • Newsletter

    Sign up for the PlanetArduino Newsletter, which delivers the most popular articles via e-mail to your inbox every week. Just fill in the information below and submit.

  • Like Us on Facebook