We are already working on a new project for the 2009 display! This page is acting as the development blog for our newest hardware addition, ShiftBrites. Below, you will find technical information, pictures, videos, and development code/plugins/software for using these great modules.
A little about ShiftBrites
From the creator's website: "ShiftBrite is a high-brightness LED module containing red, green, and blue elements. It uses a simple clocked serial interface to receive a 10-bit brightness value for each color, resulting in over a billion possible colors. Each input is buffered and output on the other side of the module. This allows each ShiftBrite to repeat the signal to the next, allowing longer cable runs between elements without excessive loading of microcontroller I/O pins. ShiftBrite elements feature current control and automatic overtemperature control (an overheating channel driver will shut off until it has cooled). Each channel can also be adjusted with a separate current control register, for fine tuning of each LED if close brightness matching is necessary. The integrated voltage regulator powers the internal logic, allowing a single 5 to 9 volt supply rail to power the ShiftBrite chain."
What this basically means is that we can create a chain of controllable LED modules that can receive 3 channel data (Red, Green Blue).
Here is a side shot of an actual module:
This is a top-view of the module. Notice the labeling on the headers to the left and right. Very easy to use:
Here is a close-up of the LED module. You can see the tiny wires interconnecting the 3 different color LEDs inside. A closer view of the header
labels too. DI = Data, LI = Latch, EI = Enable, CI = Clock
This is the bottom of the module. The Chip in the center is a A6281 from Allegro, which comes only in a 16-terminal QFN package. Only 3mm square!
Controlling the ShiftBrites
The example provided on the creator's website was written for an Arduino. I've never developed for an Arduino before, but taking a look at the code references, I knew I could easily control this module using a PIC. PICs don't have a shiftOut function, so a software SPI interface could be used or created to control the modules.
My problem... I didn't want to control the modules using a PIC or other serial device. I wanted to control it using the printer port on my PC. Yes, yes, I know- a very dated piece of hardware, but I had some specific reasons why I wanted to use it this way. The only problem with the printer port is that it is designed to send data in a parallel format, 8 bits at a time. The challenge here was to write some software to pulse a parallel port pin to create the serialized chain of data. From the creator: "ShiftBrite modules receive data in a simple clock/data/latch format. Place a logic level on the data pin, pulse the clock pin, and move to the next data bit. Once all data has been sent, pulse the latch pin to load the new data into the LED PWM registers. Since each ShiftBrite acts as a 32-bit shift register, it passes the last bit to the next ShiftBrite in the chain on every clock pulse. This allows many ShiftBrites to be controlled from the same set of control lines; simply shift out 64 bits of data for two ShiftBrites, 96 bits for three devices, and so on. However, this does mean that in order to update one LED, the entire array must be refreshed."
Connecting the hardware
Here's what the pinout of a printer port looks like:
I connected my ShiftBrite like this:
Parallel Pin 2 (Data Bit 0- 0001) --> ShiftBrite DI
Parallel Pin 3 (Data Bit 1- 0010) --> ShiftBrite CI
Parallel Pin 5 (Data Bit 3- 1000) --> ShiftBrite LI
Parallel Pin 25 (GND) --> ShiftBrite GND, and Power Supply GND
Regulated +5vdc power --> ShiftBrite V+
Power Supply GND --> ShiftBrite GND
Power Supply GND --> ShiftBrite EI (ties enable pin to ground, so it's always ready)
Writing the software
My Language of choice has always been Visual Basic 6, however, it doesn't have direct access to the printer port, without using a sluggish DLL call. I first decided to work with VC++. I was able to import the inpout32.dll and call the printer port that way. You can't use _inp or _outp in Windows XP because of protected mode. You can download my VC++ test code here. I left in a ton of commented code, so you can have an example of some other things I was trying.
Now having some test software, and getting back into things in C++, I decided to start looking at developing a plugin for Vixen Lights. From the Vixen Lights website: "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 closed-source, however it has the ability to import plugins other people have developed in order to control their special hardware. I was able to find some documentation on their site on the different Classes, Properties, and Methods Vixen uses. I now had a foundation to start with. I decided to download (free from Microsoft) Microsoft Visual C# Express 2008. I wanted to utilize C#, because I knew other plugins were developed in it, and Vixen itself was witten in it. So if I needed any help, I knew the resources would be there.
After a rough learning curve, I was writing my new plugin, and translating my test program from C++ to C#. There are so many things that you can do with Vixen, it was a bit overwhelming sorting everything out. I was eventually able to develop my own plugin (download it here). You'll want to place it in your plugins/output directory. Also, this plugin was developed for Vixen 2.0, using .NET framework 2.0.
Test Videos
This video is or an example sequence that utilized 3 channels to control 1 module. Each channel represents either Red, Green, or Blue. Having multiple channels on at once allow a user to mix a variety of different
colors. The inset in the video is a high FPS, which shows how the PWM control on the ShiftBrite works. As we percieve dimming, the module is actually rapidly blinking.
This video shows the sequence I made to test in Vixen. The video inset shows the actual hardware reacting to the timed events. Each column in the program represented 50ms timing. I've had no problem updating
2 modules at once at this speed.