Christmas light displays winking and flashing in sync to music are a surefire way to rack up views on YouTube and annoy your neighbours. Inspired by one such video, [Akshay James] set up his own display and catalogued the process in this handy tutorial to get you started on your own for the next holiday season.

[James], using the digital audio workstation Studio One, took the MIDI data for the song ‘Carol of the Bells’ and used that as the light controller data for the project’s Arduino brain. Studio One sends out the song’s MIDI data, handled via the Hairless MIDI to serial bridge, to the Arduino which in turn sets the corresponding bit to on or off.

Tutorial: The Music Light Show
https://techmusician.wordpress.com/2017/01/01/the-arduino-lights-project/

This Arduino project creates a music light show by controlling a number of lights according to a song in correct sync with the music. It uses MIDI signals from a music software running on a computer to sync the lights with the music.

Vixen is software for do-it-yourself lighting automation displays. Most popular at Christmas, computer-controlled displays are becoming increasingly popular for other holidays as well. With a PC and some hardware, anyone can have a professional-looking lighting display synchronized to music.

Vixen is geared primarily toward the DIYer. For those that prefer a packaged all-in-one solution, there are commercial solutions available such as Light-O-Rama. For those that prefer a lower-cost DIY solution, Vixen may be the software for you. There is a broad base of software plug-ins to support different hardware designs. Additionally, you can created your own plug-ins to support your hardware.

A project I have been involved with to create nice light patterns for Christmas trees and general lighting in a couple of cities in Romania.

We are using Arduino Micros which output to a couple of TLC5940-s, which, in-turn are driving some serious high current TRIAC-s. These are 12-15 meter high trees with a cobweb of wires and lights drawing a combined power of 20-30 amps.

The patterns are taken from Vixen Lights 3 by exporting the channel values on a fixed resolution and replayed on the Arduinos.

Final version:
https://www.youtube.com/watch?v=99Zc80tTTkI

Saks Fifth Avenue Winter Palace Holiday Light Show
http://controlgeek.net/blog/2016/1/2/saks-fifth-avenue-winter-palace-holiday-light-show

One of the main points of this project was to be able to drive the ‘display’ at a high framerate. Most of the projects you can find on the internet using NeoPixels have some kind of lame effect or very low framerate, while the pixels themselves are capable of doing full color, 24 bit, 33 frames-per-second video (when you have 500 of them). I also wanted to make sure my video had no tearing or jittering, and I wanted antialiasing to make things looks smooth.

To drive the LEDs, you need to produce a 400kbit/sec signal. The signal itself is quite simple; each pixel’s data is output sequentially, each pixel takes 24 bits, each bit is a HIGH/LOW combination on the data line, with differing timings for HIGH and LOW depending on whether you want to output a 1 or a 0. Sounds simple enough.

So all you need is a something to generate that signal. Now 400 kbit/sec isn’t very much even for 10-year-old PC’s, but you need to find some way to output it in the right format without having to buy specialist hardware. There are several options to do this directly from your PC like using your parallel port (if you have one) or maybe using your audio port.

But there is one more output port. It’s easy to use, most computers have one, and the spec is clear: it’s your VGA port.
Using VGA port as general-purpose DAC

What I ended up using was:

Resolution: 840 x 1000
Dot clock: 28 MHz (interestingly, this is a frequency that was supported by IBM’s original VGA standard, back in the 90’s)

This means the VGA card will output 28 million pixels per second. This gives me 28M / 400K = exactly 70 pixels for each WS2811 bit. And 840/70 = exactly 12 bits per scanline. So each scanline of my frame will represent 12 bits, and for 500 LED’s I need 500 x 24 = 12000 bits, which is 1000 lines, hence the 1000 lines in the resolution.

This gives me a refresh rate of 28M / 840*1000 = 33.33 frames per second.

And all I have to do to output all of the data for all of my LEDs is to ‘show’ something on my screen and send it to VGA. Simple as that! In fact, in first tests, all I did was show a pre-generated PNG in full-screen on my VGA output, and connect the VGA to the WS2811 string.
It is really that easy?

Hm, no, not really. There are three problems:

Hsync. VGA wasn’t made to continuously output data on R, G and B, since there is a ‘blanking period’ at the end of each scanline, which breaks my timing
VSync. Same thing, but after the last line. And this interval is a lot longer
Voltage levels. VGA uses 0.7V peak-to-peak. This means that at full-on White, the voltage on the VGA port is 0.7V. And my LEDs are expecting 5V at HIGH. That is certainly not going to work (Trust me, I tried)

Fixing the HSync

This was actually relatively easy to solve. It turns out that most video cards will allow you to drive them with very, very short horizontal blanking periods.
Fixing the VSync

Turns out this is not a problem at all, really. In fact, it is a very useful feature.

The data that you send to WS2811 isn’t actually displayed by the LED’s until you send them a ‘show it’ signal. The ‘show it’ signal is sending a LOW signal for more than 50 uSec. Well, that’s great, because the vertical blanking period is LONG. Much longer than 50 uSec.
Fixing the voltage levels

came up with a circuit
Software

So, now I have all the hardware I need, next is to find an efficient way to generate the framebuffer that I need to ‘display’ on my VGA port.

The software I use is:

Ubuntu 15.10 (or something like that)
X Windows
Python
OpenGL

System setup

I wanted to use Linux so I could SSH to my christmas lights in the garden. So I installed ubuntu and proceeded to spend hours trying to figure out how to get X-Windows to have a separate output just for the VGA, to force it to output on VGA even though there wasn’t a monitor connected, and to get it do use my magic 839×1000 resolution.
Rendering

Drawing a pattern like this is easy; you can just draw some lines or boxes in the right place. Still, with 400000 bits to render, that’s 400000 lines or boxes to draw for each frame.

Since I know a bit of OpenGL and GLSL, I decided to write the whole thing in Python and OpenGL. The nice thing about this is that I can offload the generation of the data pattern that is shown above to my GPU using GLSL, since this kind of workload fits the GPU very well

If you were wandering around Prague this Christmas season you may have spotted a Raspberry Pi 2 controlled Christmas tree. But you had to look quick because it was on the back of a special tram car that lubricates the rails around the city to reduce noise. The colors on the tree were determined by a web site that allowed visitors to change the colors. The same system, with a few adjustments, controlled a tree in the entrance hall of Czech Technical University in Prague at Karlovo.

The adjustments weren’t trival. Power was a problem, for one. The electrical noise from the tram’s drive motors needed to be filtered by using a switching power supply. Cold temperatures might have created a frozen Pi so they added a heater. After all, everyone loves warm Pi. The LEDs on the tree were handled by a WS2811 addressable LED driver chip.

The yuletide fire is out, so we’re starting to receive this year’s Christmas hacks. [Chris] sent us his awesome video-mapped tree lighting hack. His project made clever use of a bunch of cool tools, so even if you’re not thinking forward to next December, it’s worth a look. Still images don’t do it justice; check out the video below the break.

The end result is an addressable string of WS2812B LEDs connected up to a Raspberry Pi Zero that can display a video image even though it’s wrapped around a roughly cone-shaped (pine) object. But this is actually more impressive than you’d think at first; how would you map a flat image to a string of LEDs wrapped around a tree?

Tree Lighting
Pi Zero
https://www.anfractuosity.com/projects/tree-lighting/

We made use of a Pi zero as a controller for the WS2812B LED strips. 15 metres (3 rolls) of these strips were
wrapped around a tree. We made use of a logic level converter to convert the 3.3V output from a Pi to 5V.