The color of things

Fun with LEDs, microcontrollers, software, and other random things...

Aurora build  Aurora  Aurora at Burning Man  About  Contact  

The Aurora LED wall: a 4 foot by 8 foot iPad-controlled, music-responsive canvas of color


            This project began as a need to fill an empty 6’ by 12’ wall in my living room above the couch. Since I have an weakness for flashing things, I thought, “what better to fill that space than lots of lights making colorful patterns?” Thus the idea for the Aurora LED wall was born. This is my largest and most involved project to-date (involving soldering, woodworking, and microcontroller as well as PC programming), so I wasn’t sure how it would turn out; but it ended up coming out much better than I expected. If you like the vids/pics/description here or have some thoughts on improvements to the wall, please let me know in the comments below!

            The lights in the Aurora consist of a grid of 544 RGB LEDs capable of ~16 million colors attached to a 4’ by 8’ wood board. The LEDs are controlled by a microcontroller, which is in turn controlled by a program running on a laptop. The computer is the brain of the system, being responsible for creating the graphics that appear on the wall, and the microcontroller relays the messages to the LEDs. The PC software connects to software running on an iPad, which allows interaction with the moving patterns. Also, the Aurora has a mode where the builtin programs respond to music, bouncing and flashing with the beat, turning it into a VJ of sorts.

            There are several programs implemented so far. One is the Belousov–Zhabotinsky reaction, implemented as a 2D cellular automata (kind of like Conway’s game of life but less pixelated and more colorful). The idea for the graphics come from a cycle of chemical reactions that oscillate as some chemicals are used up and others are created. The resulting patterns look like smooth waves of color that sometimes repeat in a loop and other times diverge. With the iPad, you can perturb the automata with your finger and see what happens, control the speed of the visuals, and sharpen the edges of the pattern. It’s worth checking out the Wikipedia page and the video above as it makes some awesome patterns. Another visualization uses Perlin noise to create constantly changing flowing blobs of color. Perlin noise is a type of computer-generated noise that injects randomness with a harmonic structure so that the smoothness or roughness of the blobs can be controlled. Interaction via the iPad lets you control the speed of the blobs, their size and their complexity. Yet another program displays a flickering fire, kind of like the old TV channels, except about 8 feet wide. It allows you to customize the color scheme so the flames can range from the standard yellow, orange and red to something like flickering pink with a green background. There are other programs as well (such as a mode where you can paint with your finger) and the code is structured so that it’s easy to create new ones that take advantage of the color palette features described below, the iPad control and the music responsiveness.

            The color palette used for the graphics is highly configurable, allowing the different visualizations to change mood, so to speak. Using the iPad, you can choose from popular color schemes found on Adobe Kuler (an online repository of color palettes), or use a random starting color with a number of different color theory strategies (e.g. complementary, tetrad, analogous, etc.) I didn’t know anything about color theory before this project but it turns out you can intelligently find colors that go well together. This is especially useful since I’m not so great at choosing colors myself. If you look at the video, you can see the different types of color schemes available.


            One of the components of the wall that both added complexity and improved the aesthetics was diffusion of the LEDs with translucent plastic. This made the wall take on a more organic form. In my opinion and based on comments I’ve received from past projects, bare LEDs look very digital, in part because they create discrete points of light. Diffusing them results in one continuous canvas instead of a grid of little bright point light sources. If you’re curious, here’s a pic of what the LEDs look like without the diffusion. To do the diffusion, I attached some prismatic acrylic lighting panels (the ones found in front of fluorescent ceiling lights) to the board about 5-6” away from the LEDs. I chose this distance empirically: too close and not much diffusion occurred; too far and the pixels melded together. It was tricky (at least for me with my lack of carpentry skills) to keep the flexible plastic at this distance; you can see the build details below if you’re curious how it ended up being worked out. 

            Something I struggled with was whether to use a microcontroller (e.g. an Arduino) to generate the graphics or use a PC.  I originally leaned towards the microcontroller route because I wanted the Aurora wall to be of a self-contained unit that didn’t require booting up and plugging in my laptop every time I wanted to use it. The flipside is that microcontrollers are obviously not as powerful as PCs, so the visualizations wouldn’t look as good. Honestly, they’re also just harder to program. I ended up deciding on the PC route after I realized that I could replace my laptop with a Raspberry Pi (assuming I can get one!). 

            Anyway, hope you enjoy the Aurora LED wall! Be sure to leave some comments about your impressions below. If you’re curious about the build details, you can find them here.


Technical details:

  • Built with 544 addressable RGB LEDs with WS2801 ICs (8 bit x 3 channels allowing ~16 million colors) in a 32x17 matrix.
  • Uses a 350W power supply and can consume up to 60mA * 544 = 32 Amps at 5V
  • The LEDs are driven by a ChipKit Uno32 microcontroller running at 80Mhz that communicates with a custom Processing sketch over serial at 921600 bps allowing a ~45 fps refresh rate
  • The Processing sketch communicates via OSC (Open Sound Control) to an iPad app called TouchOSC with a custom control panel layout
  • The audio responsiveness uses fast fourier transforms (FFT) on line in audio to detect beats on low, middle and high frequency bands
  • Different color theory strategies for building the color palette are supported such as complementary, tetrad, compound, and others in addition to downloading colors from Adobe Kuler
  • Uses a gamma table with gamma of 2.5 to adjust the LED brightness
  • Built with a 4’ x 8’ piece of ¾” plywood (solid!) and 2x3 beams to form the frame
  • The diffuser is made of 4 2’x4’ clear prismatic acrylic lighting panels distanced ~6” from the LEDs



  • toxiclibs colorUtils and colorLibs for Processing
  • TouchOSC for iPad & oscP5 for Processing
  • Simon Dixon for part of beat detection concept from “ONSET DETECTION REVISITED” Proc. of the 9th Int. Conference on Digital Audio Effects (DAFx-06), Montreal, Canada, September 18-20, 2006
  • Ryan Govostes and Jim Bumgardner for the code from which the Perlin noise program was adapted
  • Alasdair Turner for code from which the Belousov–Zhabotinsky reaction program was adapted
  • Mick Hornbeck for help with the woodworking design


  1. theskileton reblogged this from gregfr and added:
    WANNNNNNNT I will probably do this the second I have some spare time.
  2. foreverjustanother reblogged this from woody
  3. woody reblogged this from gregfr and added:
    Oh my god this is the coolest thing ever.
  4. geoffrichardson reblogged this from gregfr
  5. gregfr posted this
blog comments powered by Disqus