It has been a while since we’ve heard anything on ColdFusion and what would be coming next. But that just means that the ColdFusion team has been very hard at work. And now the latest and greatest version has arrived. You can download the new version at http://www.adobe.com/products/coldfusion-family.html

Now, let me go over some of the things that are new or have changed:

• Security enhancements to protect you from cross-site scripting etc
• Dynamic and interactive HTML5 charting
• Improved webservices support with Axis2
• A very greatly improved scheduler (for scheduled tasks)
• Enhanced caching to boost performance
• Support for HTML5 websockets (which is plain awesome!)
• Microsoft exchange server integration via Exhange Web Services (EWS)
• HTML5 video player support with fallback to Flash Player
• Enhanced bi-directional Java integration
• …and many other features

Let me comment on some of those topics. The HTML5 websockets integration is a really cool feature that allows you to conduct bidirectional communication between several clients at the same time. It is an alternative to the BlazeDS Java integration. You see the term HTML5 popping p everywhere nowadays and thus also in ColdFusion. Adobe is keen on becoming a leader in the HTML5 technology as well and I personally think this is a very good step in that direction.

One thing I find really cool is the fact that the Flash player is now being used as a fallback technology in case HTML5 cannot be rendered. It used to be the other way around, with HTML being the fallback. To me that sounds like HTML5 still has a long way to go before becoming a standard in the industry. Being at the cutting edge of technology myself, I sometimes forget that there are still people out there that use IE6 and not everyone is keen on updating their tools every few months. Especially companies are more reluctant to do frequent updates. They rather wait for a while and do a major update like once a year even. But again, Adobe has obviously though of that and has foreseen that fallback mechanism, so you can use the feature anyway and you don’t have to write some hacks to see if it can or cannot be used.

The extended bi-directional Java support is also something I find very useful. Now you can not only use Java classes inside of ColdFusion, but you can also write ColdFusion components and use them in plain Java code as well. Perhaps this will make the Java guys less reluctant towards ColdFusion technology, because any way you look at it, ColdFusion IS Java. It’s only been made a lot easier and faster to work with.

And of course I mustn’t forget the ORM feature. This is not really new and it’s also not really enhanced that much, but it is still a feature that is not enough used in my opinion. OK, it’s definitely not the holy grail for database applications and query performance enhancements are not always that easy to implement. But it is still a powerful feature for Rapid Application Development. You can even use it in your Flex and AIR applications, which keeps you from bothering yourself with creating the local database, synchronising data with the online server etc. The ORM feature does it all for you.

In honour of this release the ColdFusion User Group Belgium is hosting one of the Scotch On The Rocks events in Brussels on May 24, 2012. If you have a chance to drop by, please do and I’ll explain more about this ORM feature in AIR on mobile devices. But you will also find a lot more great speakers who will explain a lot more about the new ColdFusion 10 features as well. So, don’t miss it and grab your free tickets at http://www.coldfusioneurope.eu

In 2012, it was not sure that the event was going to take place again, because of some setback in the past. But there was no way this event was not going to happen one way or another. So, instead of holding it in one single place, they’ve decided tot take it on tour again, as they’ve done a couple of years ago already.

Scotch On The Road (SOTR) 2012 – ColdFusion 10 Edition will stop at the following locations:

• May 21 Munich
• May 22 Zurich
• May 23 Paris
• May 24 Brussels
• May 25 Amsterdam

So, amongst the other event locations the Belgian ColdFusion user Group is proud to be hosting one of the events in collaboration with Adobe Systems in Brussels on May 24, 2012.

You can find more information about speakers and schedule at http://www.coldfusioneurope.eu/. You can also order your FREE ticket for the Brussels event right here.

Programming the cube

If you are somewhat used to programming in the Arduino IDE you know that there are 2 main functions that you use for programming your input and output, namely setup and loop. You also use the digitalRead and digitalWrite methods to get and set values from and to certain input or output pins on your Arduino board. An example code is shown below that makes an LED blink at timed intervals.

void setup() {                
  // initialize the digital pin as an output.
  // Pin 13 has an LED connected on most Arduino boards:
  pinMode(13, OUTPUT);     
}
 
void loop() {
  digitalWrite(13, HIGH);   // set the LED on
  delay(1000);              // wait for a second
  digitalWrite(13, LOW);    // set the LED off
  delay(1000);              // wait for a second
}

While this way of working is great for most projects, in our LED cube these methods are just way to slow to be used. Why? Well, since we are using a system of multiplexing, which means that not all LEDs are turned on at once (although they may seem to be because of the principle of persistence of vision), we will have to turn the LEDs on and off several dozens, if not hundreds, of times per second. The general functions in the Arduino IDE are just not created to do exactly that.

If we cannot use the standard functions provided by the SDK, then what do we need to use? We are actually going to address entire pin ranges at once. For example, the 8-bit data bus is going to be addressed as 1 single unit, as well as the 3 bits for the timer IC (74HC138). But to be able to do that, the setup function is going to look quite different.
The Arduino chip (ATMega 328) is divided into 4 ports (port A, port B, port C and port D) and each port consists of 8 pins, which correspond to 8 bits. That means that if we are going to put the value of 7 to port C, for example, 3 pins on the Arduino are going to be set at once. We need this system to be able to use the 74HC138′s all 8 output lines when providing only 3 input lines.

If you hooked up the cube as I’ve described in the previous sections, you Arduino chip’s port configuration should be:

• port B, bits 0-2: address bus or timer IC (digital pins 8-10)
• port B, bit 3: output enable (digital pin 11)
• port B, bits 4-5 : layer selection (digital pins 12-13)
• port C, bits 0-5: layer selection (analog pins 0-5)
• port D: the data bus (digital pins 0-7)

The other pins on the Arduino chip are used for power (VCC and ground), the chrystal and some other features. These will not be used in our programming scheme.

With this in mind the setup function looks like this:

void setup() {
  int i;
 
  // Set all pins as output pins
  for(i=0; i<14; i++)
    pinMode(i, OUTPUT);
 
  // pinMode(A0, OUTPUT) as specified in the arduino reference didn't work. So I accessed the registers directly.
  DDRC = 0xff;
  PORTC = 0x00;
 
  // Reset any PWM configuration that the arduino may have set up automagically!
  TCCR2A = 0x00;
  TCCR2B = 0x00;
 
  TCCR2A |= (0x01 << WGM21); // CTC mode. clear counter on TCNT2 == OCR2A
  OCR2A = 10; // Interrupt every 25600th cpu cycle (256*100)
  TCNT2 = 0x00; // start counting at 0
  TCCR2B |= (0x01 << CS22) | (0x01 << CS21); // Start the clock with a 256 prescaler
 
  TIMSK2 |= (0x01 << OCIE2A);
}

As you can see in the comments in the code above, I’ve also set an interrupt so we can do some stuff there. Since the Arduino programming (or hardware programming in general) consists mainly of running an infinite loop, we need to be able to stop it, change some parameters etc at certain intervals, hence the interrupt routine. Now, in the Arduino documentation you can find that the ISR interrupt routine is called whenever the timer/counter reaches the OCR2A value.

ISR (TIMER2_COMPA_vect) {
  // All layer selects off
  PORTC = 0x00;
  PORTB &= 0x0f;
 
  PORTB |= 0x08; // output enable off.
 
  for (int i=0; i<8; i++) {
    // Put the data on port D
    PORTD = cube[current_layer][i];
    // Trigger the latch IC to move the input to the output pins
    // via the use of the 74HC138 timer IC
    PORTB = (PORTB & 0xF8) | (0x07 & (i+1));
  }
 
  PORTB &= 0b00110111; // Output enable on.
 
  // Remember the layers are controlled by analog pins 0-5 
  // and digital pins 12 and 13.
  if (current_layer < 6) {
    PORTC = (0x01 << current_layer);
  } 
  else if (current_layer == 6) {
    digitalWrite(12, HIGH);
  } 
  else {
    digitalWrite(13, HIGH);
  }
 
  // Enable the next layer
  current_layer++;
 
  // If we run out of layers, just start at the beginning again
  if (current_layer == 8)
    current_layer = 0;
}

With these methods in place you’re now all set for programming your special effects on the LED cube. The loop method just implements an infinite loop of your special effects. If you want to start with some example code I suggest you download it from this location. (I’m not taking any credit for this startup code, but I have used it to get cracking at the effects myself. Once you understand how the existing code works it is easy to create your own effects.)

This also concludes the blog post series on the Arduino LED cube. Should you use this to build one yourself and to create your own special effects, please leave a comment with a link to some photos or video material. I’m always curious to see what everyone else is up to. Have fun!

• The improved content-aware fill
• The new non-destructive crop tool
• The patch tool combined with content-aware fill
• The new content-aware move tool
• Some tilt-shift blur filtering
• Fish-eye lens correction to the extreme

These features are only a subset on what has been improved. Amongst other things there is the new “Freddy Mercury” graphics engine that is also used for complex calculations…

I suggest you download the béta release here and start playing around with it. Have fun!

Attaching the data circuit wires

The first step we need to do is to make sure that, when we want a certain column to be addressed, the data is transmitted to the proper latch IC (74HC574). Now, this is actually done in 2 steps. The first step is to actually get the data to the IC. The second step is to trigger the right latch IC so that specific data is transmitted to the outgoing pins of that IC.

As you can see in the image above, the 8-bit data transfer to the latch ICs is done in a way that resembles a bus topology. The first latch is connected to the proper Arduino ATMega328 pins and all the other latches are attached in a parallel circuit. That means that the blue wires run from input pin 1 on latch 1 to input pin 1 on latch 2 and input pin 1 on latch 3 and so on… The same system applies to the other input pins as well.

Now, you may wonder which pins we need to use on the ATMega328 for these connections. If you look at the schematic below, you can see the digital pins 0 to 7. Those are the ones you’ll need to connect to the latch ICs.

The next pin on the latches that we need to connect is the Output Enable pin. Powering this pin will allow you to actually use the latch and to have it retain its last output value. Again we use the same parallel circuitry, but since we only need 1 pin on the ATMega328 this time it’s a lot less work to do. The pin to use for this one is digital pin 11 and you can see it in the image below as the yellow wires.

The third step is to attach the wiring that ensures the proper latch IC is triggered at the right time. This is where the so called 'clock IC' (74HC138) comes into play. Since the Arduino chip doesn’t have enough output pins to connect them directly, we use the 74HC138 to convert 3 input lines into 8 output lines. How does this work? Well, it’s just a simple binary formula. With 3 bits you can count to 8, so setting those 3 bits at the same time on and/or off will send a small current through the output port that corresponds to that binary number. The pins you need to connect on the ATMega328 are digital pins 8 to 10.

Each of the 8 output pins on the 'clock IC' need to be connected to one of the latch IC’s clock pin. This is a pin that reacts to a drop in current, so when we want to address a certain latch we will have to set that clock pin high, put the data onto the bus and then pull the clock pin low again to actually enable that output.

If you look carefully at the green wires in the image you can see that the output pin 8 is actually located on the other side of the other output pins. It might be easily overlooked when you’re soldering them on. you just go pin 1, pin 2, … until you soldered the wrong pin to the output. Not that I was guilty of doing that, but I certainly had to think twice which pin it was that I needed to skip .

The final step in wiring the brains of this contraption is to connect the transistors that control the layers of our LED cube. In the image below, these are the purple wires. On the ATMega328 you connect them to the analog pins 0 to 5 and the digital pins 12 and 13. These should be the last available pins on the ATMega328 chip.

Now you have all the necessary wiring done and you can get cracking at programming the LED cube. In the next part I’ll discuss how you set up the programming in the Arduino IDE so you can start to create your own cool effects.

Building the brains: soldering the components

The first and most important thing you need to do is to determine the actual layout of all the components. This means you’ll have to place all of the components on the board without soldering them, just to make sure your layout leaves enough space to have all the components on there. It would be a shame soldering all of the components on there only to find out in the end you don’t have enough room left for the last couple of resistors or ICs :-S.

Once you are sure you have a correct layout, you are best off starting with the IC sockets for the 74HC574 ICs and the 100 Ohm resistors, together with the male pin headers. These will be connected to the LED cube and every latch IC will be connected to one of the UTP cables you prepared in the previous step. That means that every LED you will turn on will be have a 100 Ohm resistor in its electric circuit. After soldering them in place, your board should look like this.

Next up are the transistors that will control the layers. Each 2N2222 transistor is rated for about 800mA, which is not enough, since it will receive the current from maximum 64 LED at the same time. Since the LEDs can go to 20mA each, that means that the transistor would get 1280mA and be fried in seconds. That is why I’m placing an additional transistor for each layer in parallel, so each layer will be turned on by 2 2N2222 transistors in parallel to split the current.

Simply put, each transistor can be seen as an electronic switch. For the NPN type of transistor you can compare it to a normally closed contact. If you supply power to it, the contact will allow the current to pass through. Otherwise not. Now, the transistor actually needs a separate circuit to trigger the switch and this circuit needs a 120 Ohm resistor in this case, to allow the maximum amount of current (20mA) to flow through the LEDs in the cube.

I’ve connected 2 transistors and resistors in parallel by outlining them on the same rows on the prototype board. For the transistor, you need to bent the base leg a little to have all 3 legs in 1 line. So, you end up with a resistor connected to the middle leg and you just mirror the situation on the same line. This allows a small wire to connect both resistors in the middle.

Then you connect the collectors and then the emitters of both transistors. And since we have 8 layers to play with, you’ll need to repeat this 7 more times. Last but not least, you need to connect the collectors of all 8 layers to another pin header to allow the UTP from the layers to connect to these transistors. The end result in soldering can be seen in the following image.

In the next step you are going to add the 74HC138 clock chip as well as the Arduino powered ATMega328, together with its crystal and 22pF capacitors. Please use the image below to connect the proper components to the proper output ports on the ATMega328 chip.

In the next images you can also see some additional soldering in place to connect the VCC line and ground to the different components. In the top view you can see some wires running on the top of the board. This is necessary because the VCC line sometimes has to cross the ground line and this is why we need these wires. In the same image you can also see there are also some additional capacitors in place to regulate the current throughout the board.

There is a 1000uF, a 100uF and a 10uF capacitor right behind the power input to get rid of the ripples in the 5V regulated power source we will be using to plug the cube into the power socket. And you can also notice another 10uF capacitor at the far end of the VCC line, which is the top of the board in the picture, right next to the transistors. It’s there to ensure some power is always available when the transistors are switching rapidly. The same rule goes for the 100nF (or 0.1uF) capacitors you can see right next to every IC socket for the 74HC574 ICs. These components also need a certain amount of current available to be able to do their job. Normally this shouldn’t be any problem, but they are there just to make sure, because if the ICs do not get the power they need in time (we are going to be switching them on and off several hundreds of times per second) you may end up with the wrong result.

This is all the soldering you need to do for attaching components to the prototype board. In the next part of this series I’ll explain how to add all the necessary wires to get this up and running.

A first question is why did I choose this dimension for the cube? You can build a cube of any size you like: 4x4x4, 7x7x7, 12x12x12, … It doesn’t matter. The only thing you have to keep in mind is that the complexity grows exponentially when moving to a bigger dimension. I mean, with an 8x8x8 cube you already have to work with 521 LEDs. If you would create a 9x9x9 cube, the number of LEDs would already be 729.

8×8 pixels is also the smallest usable dimension to display text. If you want to do that, an 8x8x8 is the minimum. And of course I also chose this dimension because it is quite handy for wiring, because then you can simply use UTP cables, which have 8 wires.

Wiring the cube

First, you need to understand how you are going to program the cube’s animations. Since the cube contains 512 LEDs you will have to be able to control 521 individual outputs. Or so you might think, because you can simplify this a whole lot by using multiplexing. What is this? Well, multiplexing is a way of programming that switches only some of the LEDs on or off at the same time. Then you quickly move to another set of LEDs and then another and so on. By doing this very quickly the yes cannot keep up and it will appear as though you are turning all of them on when in fact only 64 LEDs will be turned on at any given time. You can see a good demonstration of this principle in the YouTube video below, where the switching is gradually increased in speed.

In our specific cube the multiplexing will go per vertical plane. That means that all the horizontal layers can be turned on at the same time and one vertical row of 8 LEDs as well. So 8 rows in a plane times 8 layers equals 64 LEDs. This system also keeps the power consumption really low as well.

The first thing you need to do is create some wires. You simply cut off a piece of UTP cable about 20-25cm long and remove the outer layer for about 5cm on one end and about 10cm on the other end. Then you unwind the inner wires and place then in a fixed order. I used brown – brown/white – orange – orange/white – green – green/white – blue – blue/white. But you can choose any order you want. Just make sure that for each cable the order is the same to avoid mixups afterwards. You’ll need 9 of these cables: one for each plane and one for the layers.

The next thing you need to do is to solder the female headers to the shortest end. This in not an easy thing to do when you do it freehand soldering, so if you have a “third hand” device lying around, please use that. If you don’t, you can also use a pair of pliers to hold the female headers in place so you have both hands free for soldering. I know the picture below is a little bit dark, but you can clearly see the end result of this operation.

The last thing you have to do is to solder the other end in the same order to on of the rows of LED legs that are sticking out through the bottom of your mould. It is also a good idea to label the cables to make it easier later on to connect the proper cable to the proper IC.

Once you’ve done this, you simply do follow the same procedure for the other rows and one last time for controlling the layers. The bottom of your mould should now look something like this.

In the next section I’ll cover the brains of this thing and we’ll be making the prototype board

Building the cube

The most important aspect of the LED cube is the fact that all the LEDs are lined up perfectly. There are some LED cube examples out there that have great effects and colors, but the whole “wow” effect is just missing because the LEDs are not lined up at all. Saying they have to line up is one thing, but since we will be soldering 512 LEDs by hand, actually accomplishing that is a whole other thing.

To make sure every single layer is lined up perfectly, I used the mould you can see below. I’ve just used a piece of wood and drew some intersecting lines on it. The distance between the intersections should be about 2mm less than the length of the shortest leg on your LED (this is called the cathode or negative side). This will allow for the legs to overlap a little for soldering purposes.

Since you’ve bought 3mm LEDs you can drill holes on each intersection with a 3mm drill bit. The bottom part of the LED will be a little bit bigger so they should fit snugly. You can see some additional smaller holes on the left, but you don’t have to worry about those right now. They will come into play later on. Once you’ve drilled the holes you are sure that all the LEDs on every layer (because these 64 holes will become 1 single layer of the cube) will be in the same position. And as an added bonus, you can use the mould as the base for the cube, because the standing legs of the bottom LED layer will fit through the holes as well.

For soldering the LEDs together I’ve started with a horizontal top row. Make sure you bend the cathode legs of the LEDs 90 degrees in the same direction for every LED and make sure they touch slightly. In my case they were all pointing to the right. Once you’ve positioned them, you can solder them together. You will also notice that the last LED will have its leg sticking out. In the end you will have to cut it, but leave it on for now. It will allow you easier access to the layer for testing purposes.

Then move on to the other LEDs and position them in vertical columns, making sure the second one from the top has its cathode leg touching the horizontal row you’ve just soldered. If you’re right-handed it is probably going to be best to start from the left and work your way to the right side of the layer. Once you’ve done all 8 columns every LED should be connected and your should have a kind of long comb structure. This whole structure is kind of flimsy at this point, so you’ll have to take some steel wire, straighten it and solder that on top of the structure. I wanted to take no risks so I actually added 3 additional reinforcement wires, as you can see on the right side of the image above.

This is also a good point to test the connections. What you’ve actually done is connected the negative legs of all the LEDs together. That means that the easiest way to test the LEDs is to have a 3-5V power source, attach a 220 Ohm resistor and use 2 small wires to connect the LEDs one by one. Actually, the value doesn’t matter that much at this point since we will be connecting the LED for a very short period, so you could use one of the 120 Ohm ones as well. Remember that I’ve told you not to cut that one leg that is sticking out? Well, you can use that one now to connect it to the negative wire. Then you can simply touch the leg that is sticking upwards of each LED with the positive wire and it should light up.

Why should you test the connections right now? Well, LEDs are electronic components and as mentioned before they don’t cope that well with heat. Since you have been soldering very close to the actual LED component, you may have overheated one the is broken now. Now is the time to find that out, so you can still replace it. That will be a lot harder if you have soldered the layers together and maybe plain impossible if you find a broken LED in the middle of the cube.

At this point you have one layer finished, so that’s one down, 7 more to go. Just be careful when getting the LED structure out of the mould to make sure you don’t bend it. This is tedious work and requires some concentration to work on this small scale, but I can assure you it’s a great stress reliever . After a couple of layers you should have accomplished what I’ve shown in the picture below. And that’s only the half-way point…

After you’ve completed all 8 layers you can start with soldering the layers together. Again you will be using the mould, so you can actually leave the last layer in there for starters. Of course, you have to make sure that the layer you put on top of it is actually parallel to the bottom one. I found the easiest way to do this is using something to put in between the layers. I’ve used some small pieces of wood that I cut to the proper thickness. The upwards pointing legs (anode) of the bottom layer have to be bent slightly to get around the LED of the next layer to connect to the upwards pointing leg (anode).

I would also recommend soldering the corners first, then the edges, the middle and again working your way to the outside of the cube. Once this layer is done, keep the bottom one in the mould and just move the wooden spacer one level up and start again. The first couple of layers are not going to feel that sturdy, but once you’ve soldered about 3-4 layers together things will feel a lot better. Again, better safe than sorry, so test each layer after you’ve soldered them together. This will allow you to find broken LEDs again or even connections you’ve forgotten to solder. After all, there are a lot of connections to do…

After you’ve completed all 8 layers, you can now safely remove the cube from the mold and turn it around. You result should look something like you see in the picture above. If you’ve tested every single LED again, you can nog finally cut off the cathodes that are sticking out to the side.

This is also the time to drill the smaller holes you saw in the first picture. These will be necessary to guide wires that connect each layer to the controller.I’ll explain that in more detail in the next part…

You have now finished the cube and you can stick all of the anodes through the 64 holes of the mould. This is not as simple as it sounds, because it is like threading 64 needles simultaneous . After you’ve done that you just bend the legs around the wooden mould on the underside and that is sufficient to hold the cube in place.

In the next part we will be adding the wires to the cube

The component list

First things first: let’s sum up the components you will need to build this contraption:

• 1 x ATmega 328pu with an Arduino boot loader (you can do without the boot loader, but then you’ll have to boot load it yourself)
• 1 x 28-pin IC socket
• 2 x 22pF capacitor
• 1 x 16Mhz chrystal
• 1 x 74HC138 IC (This will act as a timer chip)
• 1 x 16-pin IC socket
• 8 x 74HC574 IC (These will control the different columns in the cube)
• 8 x 20-pin IC socket
• 512 x 3mm LED (You can choose whatever color you like, but I liked the blue ones)
• 64 x 100 Ohm resistor (Metal film resistors have a smaller tollerance, so I chose those)
• 16 x 120 Ohm resistor (Again, use the metal film ones)
• 16 x 2N2222 transistor (You could use the PN2222 as well, but I couldn’t find them on time)
• 1 x 1000uF capacitor
• 2 x 100uF capacitor
• 1 x 10uF capacitor
• 10 x 0.1uF ceramic capacitor
• 72 x male pin headers
• 72 x female pin headers
• About 2m of UTP cable
• 1 x power connector
• 1 x on/off switch

If you look at your local electronics store, you will find that all of this will cost you quite some money. However, I don’t think you need to buy these expensive components when you can find all of these online on eBay for a tenth of the price. Sure, you’ll end up with too many components because they usually come in large packages, but that gives you another reason not to stop with this one project

Including all the spare parts I have left now, the total cost for this little project comes down to around 100 Euro or 130 US Dollar. Which in my opinion was well worth it.

Just one thing to look out for when buying the LEDs. The LEDs I bought have a leg length of 17mm. This makes the cube a bit smaller than I had anticipated (about 12cm on each side), but still, the result is not bad at all. If you buy LEDs with 25mm legs your LEDs will be spaced further apart (about 18cm on each side), making it more transparent as well. The choice is yours.

Also, using the IC sockets is completely optional, but I’ve found it very helpful, especially for the ATmega328 chip, because it makes it easy to take the chip out of the board and put it into an existing Arduino board for easy programming. Another good reason for using these IC sockets is the fact that you don’t risk frying your ICs while soldering them on the board. Electronic components have a tendency not to cope very well with the intense heat of soldering. If this is your first project, I definitely recommend it to avoid having to throw away some fried ICs.

In the next part I will take you through the process of creating the actual LED cube itself

There a basically two well-known solutions for you when you want to indulge yourself in physical computing and some real-world fun and games: Arduino (http://www.arduino.cc) and Phidgets (http://www.phidgets.com). The biggest difference between the two is that with Phidgets you can buy plug-and-play circuit boards that are ready to go. You just connect them together and hook them up to a main controller board, which usually runs on a USB connection with your computer and you’re set to go. Phidgets is very easy to use and I highly recommend it if you want to get started with this type of applications, since you don’t really need to know much about electronics to get started. The downside is that it doesn’t run stand-alone (unless you buy the super expensive SBC stand-alone board which runs a full Debian OS).

The advantage of using Arduino is that it does run stand-alone and it is even not that hard to get the chip out of the circuit board and onto a prototype board which you can build into any application you like.The biggest downside to Arduino is that you have to have at least some basic knowledge of electronic components and wiring. I don’t really consider this to be a downside, because you can make whatever you want, but it does make it a higher threshold to get started with it. Another downside is that the programming is a bit harder to do, especially for this LED cube type of application, since you will not be using the standard programming interface you might be used to if you’ve been doing some Arduino programming before. Having never touched a soldering iron before, I decided I liked the challenge and chose the Arduino approach to create a stand-alone version which I can easily reprogram if necessary.

Before I get started on telling you how to build such an LED cube, let me quickly show you the end result:

Now, this will be a multi-part blog post spread over the next couple of weeks, since there is a lot of information to share on this. But I can already say that some credits have to go to the author of this post for getting me started on the project. Even though there are quite some mistakes in the post and it has been made more complex that necessary for my purpose and intention, it provides a good starting point. So, keep tuned for the first part of the build…

In the next part I’ll guide you through the components you’ll need to complete this project