Voxel Shield Makes Driving LED Cubes Easy


An Arduino can handle running a small LED cube on its own, but if you’re planning on building something big, eventually you are going to run out of pins. For something like an 8x8x8 cube, odds are you will have to turn to shift registers to get the job done. While you could design a breakout board full of shift registers on your own, [Connor] has done the work for you and produced an easy to use Arduino LED cube shield.

He calls his creation the Voxel Shield, and it incorporates 9 SN74LS595N shift registers and an external power plug for all of your LED cube needs. The shield can handle addressing up to 512 LEDs, making it an easy way to drive an 8x8x8 cube or even a 64×8 LED matrix.

It’s a nice clean and compact way to drive a large number of LEDs, so if you have the need, be sure to swing by his site – he has made his schematics and board layout files available to all comers.

[Thanks, Thomas]

21 thoughts on “Voxel Shield Makes Driving LED Cubes Easy

  1. I’ll have to check this out later when I have time to look over all the details of the build. I was hoping the new Arduino DUE would have enough pins to get away with an 8x8x8 LED cube, but this sounds interesting and is doable right now.

    I just finished a 4x4x4 LED cube on an Arduino UNO as a proof of concept and to work out a few issues before I decided to dump the money into a 8x8x8 cube. I thought I was going to have to dive into AVR programming to pull off a 8 LED cube.

  2. This would save lots of time..

    If it was me (and its not) i would make that board with 1 IC…

    1 x XC3S250E FPGA by Xilinx… If you get the 144pin version you have 108 I/O pins to use

    Count: 1 for SERIAL, CLOCK, RESET thats 105 pins for use.

    Thats 3 pins for control.

    It would be like having 13 595’s on 1 CHIP also it can reach speeds up to 300Mhz!

    But all in all, great work really!

      1. someone doesnt know fpgas here…

        9 shift registers = $9

        But 1 FPGA can be used as 13 595s,, so more like
        13 shift registers = $13

        1 EEPROM = $1

        The reason i suggested a FPGA was mainly because its customizable… like if you wanted to make the simplest board you can because you can setup the pin mapping to however you like to make creating a board easy!

        EEPROM is not a issue. They are cheap. The crystal is not needed it can run from the clock line. It will work upto 300mhz clock. (or so)

        Resistors anyone can get 1000 for like $3-$4 so not a issue… Imagine having 105 pin shift register for $20… its pretty cheap and simple to design with compared to 13 ICs on a board…

        It would be a horror to layout that.

      2. 1. The Arduino has no clock line output so you would have to write code for the Arduino to provide a clock.

        2. 99% of the people that can program the Arduino know nothing about VHDL or Verilog so the board would be completely useless to them.

        3. You have given your circuit no way to communicate with the arduino.

        4. While each pin may provide 100mA, there is a chip limit so ALL pins can’t provide 100mA at the same time. I don’t have time to find the spec sheet to look this up.

        Yes, some of us do know fpga’s.

        Let us know when you are coming out with your board and it is listed on the web site here. It’s so easy to tell people how to do it, it’s not so easy to do it yourself.

      3. you guys are really comparing shift regs to an FPGA?
        with the FPGA you can do very very very much more delicate things. Let me explain what I’m talking about.
        The shift registers need a microcontroller that constantly shifts data in, all the time, if it stops the LEDs will die. This costs a lot of cpu power. Let’s calculate some stuff for the 64×8 matrix. You need 64 SPI clocks for one row. 8*64 clocks for one “image”. 100Hz refresh rate, thus 100*8*64>50k clocks per second. That’s alright, an AVR can do that. Hey, let’s do some pwm-fading. 100*8*64*255>13mio clocks per sec (for 8bit pwm). This is impossible with an avr, AND you still have to load all the data from the flash and so on.
        On the FPGA you can do that with ease. The AVR gets an SPI link with the FPGA and whenever you wanna refresh the image, just upload the new data, the FPGA will display it with 0 more CPU time. Oh, and uploading one image takes 64*8*8=4096 SPI clocks. Sounds better, huh?
        Also I don’t think any FPGA can handle 100mA pin current o_O. An FPGA doesn’t use EEPROM either, it’s flash.
        Of course the FPGA circuit is more complex, but it’s also way more powerful.
        Also take into consideration, that an AVR is the wrong thing for driving matrices at all imo. You should rather use an ARM or something, that has, you know, enough flash/ram to actually hold animations and everything.
        A different approach would be to implement a softcore in the FPGA together with the matrix controller and add some external flash for animation data.

  3. fred the only thing there that made sense at all was people dont know FPGA like that…

    1 & 2 . I can create a 595 clone with 105 pin output that can use the exact same code as posted in the example. a Clock line is a also needed for the 595 if im correct. That same like that acts like a clock is a CLOCK

    The power issue should be resolved with pull ups

    I dont plan on doing a 105 pin version just for you… if you want you can check out my 24bit shift register code


  4. You really can’t drive LEDs properly from that M74HC595B1R (note, it’s NOT a 74LS595 as the HaD writeup says).

    The output current per pin is only guaranteed to be 6 mA. You need 20 mA+ to get decent brightness.

      1. I’m aware that the M74HC595B1R can only source 6mA according to the datasheet. I used it because I’m broke and I know from experience that parts like this work beyond specifications. The pinout is exactly the same as the 74LS595, so I recommend you use that instead, I was just trying to save some money.

  5. Sorry but using shift registers for every voxel in an LED cube is inefficient, power hungry and expensive. The better way is to use shift registers for a single 8×8 layer of the cube, and then use 8 cheap transistors to drive each of the 8 layers. Then in software you can implement a scanning pattern of layers 1-8 using 8 port pins on the micro, and update the shift registers each time to achieve the cube effects and animation. Total number of shift register outputs drops from 512 to 64, and the maximum power consumption is the max consumption for one layer of the cube, so roughly 64 * 10mA = 640mA, since only one layer of the cube is switched on at a time. You could potentially be drawing over 5A of current from this 512 LED shift register shield which is ridiculous.

    1. This seems like a classic case of someone who didn’t bother to RTFA.

      As stated in his project summary:

      Positive Outputs: 64
      grounding pins: 8

      Sounds like exactly what you are describing…

Leave a Reply

Please be kind and respectful to help make the comments section excellent. (Comment Policy)

This site uses Akismet to reduce spam. Learn how your comment data is processed.