Around this time last year, [KopfKopfKopfAffe] was enlisted as a set designer and was told to build some sort of light effects for electronic music parties. The budget for the project wasn’t much at 200 Euros, but he did manage to build decent 5×5 RGB LED matrix that is fully controllable by a computer.

[KopfKopfKopfAffe] didn’t have the time or money to wait for manufactured PCBs, so a bunch of perfboard was placed in a CNC mill with a pen to act as a plotter. All the lines that needed soldered were drawn on by the mill, a feat that probably saved hours of looking at the design before committing solder to iron.

A total of five boards were constructed, each one capable of controlling five RGB LEDs. Each board can be dasiy-chained with an RS-232 serial connection for further expansion. The only thing that’s needed to control the matrix is 17 bits that includes an address and RGB color data for each LED. The system only cost about 10 Euros per node, but we think that could be significantly reduced by leaving out the Molex and DB-9 connectors. [Kopf] project turned out very nice, check it out after the break.

When [trandi]‘s wife saw a cute night light at Ikea, she had to have it. She actually bought several of these for when her husband would inevitably crack one open and start tinkering with the microcontroller inside. The inevitable hack is pretty cool, and also gives us some ideas for interfacing with Android on the cheap.

The build started as an Ikea Spoka night light, an adorable anthropomorphized night light with a squishy silicone skin. Inside the Spoka are a dozen tri-color LEDs that [trandi] can cycle through with the push of a button. After deciding to control the lights inside the Spoka with an Android phone he reached for an IOIO Android breakout board. Fate intervened and [trandi] ended up with a ridiculously cheap Bluetooth modules that provides a simple serial connection to other Bluetooth devices.

The build reuses the blue, red, orange LEDs in the night light but replaces the no-name 8-pin micro with an ATtiny2313. [Trandi] wrote a small Android app to control the color over a Bluetooth serial connection. Check out his demo after the break.

[Shameel Arafin, Sean McIntyre, and Reid Bingham] really dig rainbows. Going by the moniker the “RainBroz”, the trio built a portable display that can be used to add cool light painting effects to pictures.

The group brings their Rainbow Machine all over the place, including parties, gatherings, and random spots on the street. Anyone is welcome to have their picture taken with the Rainbow machine, and each subject is given a card with a URL on it, so that they can check out their picture whenever they please.

The display consists of addressable RGB LED strips and an Arduino from Adafruit, along with the associated support mechanisms for moving the LEDs. The real magic is carried out by the LPD8806 light painting library, also from Adafruit, which enables the RainBroz to create all sorts of images with little fuss.

As you can see in the video below, the Rainbow Machine seems to get a pretty warm reception from just about everyone, even people grabbed right off the street. It looks simple enough to build, so why not put one together for your next gathering?

[Craig Lindley] recently finished building his own RGB LED cube project. It’s made up of four layers of 4×4 LED grids, but you may notice that the framework that supports the structure is not the usual ratsnet of wires we’ve come to expect. They’re actually long, thin circuit boards. [Craig] grabbed the Rainbow Cube kit sold by Seeed Studio for this project. But instead of pairing it with their Rainbowduino driver, he built his own to give him more options on how to control the blinky lights.

He’s using an Arduino Uno to control the display, choosing TLC5940 driver chips to safely provide the juice necessary to light up the grid. These drivers also offer 12-bit pulse-width modulation for easy color mixing. Driving the LEDs directly would have taken a large number of these expensive chips (over $4 a piece), but if multiplexed the design only calls for two of them.

Check out a video of the finished cube reacting to music thanks to the microphone and amplifier circuit [Craig] build into the driver board.

There’s not much to be gained by living in a discotheque but colored lights are awesome, especially when they’re as well implemented as [michu]‘s StripInvaders.

The StripInvaders project takes a gigantic 5 meter LED strip with WS2801 controllers and turns it into an Ethernet-enabled 24 bit display with the new Arduino Ethernet. While the Ethernet-enabled may seem a little superflous, [michu] implements it quite nicely. The entire 5 meter LED strip can be controlled from a tablet or smartphone.

Apart from a tablet/smartphone interface with OSC, there’s also mDNS support so we’re sure the StripInvaders could make for an interesting LAN party with the appropriate scripts. While the cost of the LED strip itself is fairly high, we’re sure some Hack a Day commenter will come up with a cheaper solution.

The firmware for StripInvaders has been posted on Github, but for a real treat, check out the demo after the break.

Hackaday reader [chrysn] picked up a 3-button RGB model DIODER light from IKEA and thought he might as well take it apart to see what he could do with it. Having seen several DIODER hacks featured here, he knew it was easily hackable, but he didn’t want to simply rehash what other had already done.

All of the DIODER hacks we have come across thus far incorporate some sort of AVR chip or add-on board to expand its capabilities. [chrysn] saw that the controller already had a PIC16F684 inside, and thought that installing his own firmware onto the existing hardware would be a far more simple solution. He installed a small programming cable onto the DIODER’s control board, and using his PICkit2 programmer, flashed the chip with a custom firmware image.

His modifications worked great, and [chrysn] says that there is plenty potential in the existing hardware to have all sorts of fun with it. Even so, he notes that there are several AVR-flavored drop-in replacements that can be used if that happens to be your microcontroller family of choice.

We can order seven segment displays in red, green, yellow, or blue all day long. One thing we haven’t seen is an RGB segmented display, so [Markus]‘ project is really interesting. He took a stock seven segment display and modded it into an RGB display.

After taking a Dremel to the back of the stock display, [Markus] was left with a seven segment light mask. A few SMD LEDs were purchased through the usual channels. The RGB LEDs were epoxied into place on the back of the light mask one at a time. Thankfully, the LEDs came with magnet wire already attached – helpful, since these LEDs are only 1.6mm x 1.2mm big.

With 32 pieces of magnet wire, [Markus] needed some sort of socket. A small piece of perfboard and some .100″ headers handled the job very nicely. [Markus] still has to work on some way to drive the 24 cathode lines his LED display. He’d like an I2C interface, but with something like an individual seven segment display, the footprint of the circuit should be pretty small. If you’ve got any tips, drop them in the comments section. [Markus] is sure to catch them there.

This year, students working for Texas Instruments as part of their Co-op program were challenged to construct a project around the company’s MSP430 microcontroller. A team of three students, [Max Thrun, Mark Labbato, Ian Cathey] decided to build something that would fit perfectly in any college student’s dorm room – an RGB LED coffee table.

We’ve covered RGB LED tables in the past, but as far as we can tell this is the first MSP430 based unit we’ve seen. Microcontroller aside, the table features a lot of items that are considered “standard equipment” when it comes to these sorts of living room LED installations. The trio installed 128 RGB LEDs into their table, isolating each one using a wooden grid, and used some frosted glass to diffuse the display a bit.

What really makes this table stand out is the software. The team wrote an application that creates a Fast Fourier Transform of whatever music is being played, in order to find beats and generate real-time visualizations for their table. The result is a pleasing display that’s sure to be a hit at parties.

Check out the video below to see their creation in action.

[Julien] let us know about his ProtoDeck. A MIDIBOX based controller for Ableton Live using a Big Max for live patch interface.

One thing that we have seen is less and less hacks for are MIDIbox projects. It is no wonder, considering now a days we have touch screen and multiple other interfaces and sound creation tools – MIDI almost seems like a dying art.

The ProtoDeck uses 87 pots, 90 buttons, and 81 RGB LEDs all controlled by 2 PIC 18F4620s. [Julien] says his main goals where to have lots of color and buttons. We think he succeeded.

[Alex] of tinkerlog created a set of 64 RGB fireflies that synchronize to blink all at once. We covered the kit earlier, but he has assembled a set of 64. Each firefly is independently controlled by an ATtiny13 that reads a phototransistor and lights up an RGB LED. The fireflies are programmed to blink a certain rate, but blink faster if they detect other blinks. After a few cycles, the fireflies begin to blink in unison. When the fireflies are arranged in different configurations, different patterns emerge. He is selling kits and has instructions for building your own. Videos of the fireflies after the jump.

Related: Jar of fireflies

We covered SparkFun’s new RGB button pad controller a few weeks ago. This is a full-color clone of the monome interface; a 4×4 grid of buttons with tri-color LEDs underneath. Each LED has 24bits of color control, for more than 16million color combinations. Up to 10 panels can be chained together to create huge button grids, like SparkFun’s Tetris table. We previously used a smaller version in our RGB combination lock.

We asked SparkFun to send us the SPI version of the button controller to test. This is a new product developed in-house at SparkFun, with open source hardware and software. Read about our experience interfacing this board below.

4×4 RGB button pad controller SPI (SparkFun #WIG-09022, $39.95)

The button pad controller is a bare PCB, we also received a button pad cover (SparkFun #COM-07835, $9.95), and two of each bezel (SparkFun #COM-08747, #COM-08746, $3.95).  The SPI version we’re working with can be driven directly by a microcontroller, or by a USB ‘master’. The USB controller version has an additional microcontroller and FTDI USB->serial converter for PC connectivity.

When the button pad arrived, we immediately sat down with the datasheet and tried to interface the board with our Bus Pirate universal serial interface. The protocol described in version 1 of the datasheet didn’t work, at all.

SparkFun open sourced this project, so we determined the correct interface protocol from the source code for the button pad SPI (ZIP) and the button pad USB controller (ZIP). We figured out most of the protocol from the source, but it still took help from SparkFun’s engineers to uncover some of the undocumented, finer points of interfacing the board. Version 2 of the datasheet (PDF) accurately depicts the interface protocol.

Connections

The button pad’s SPI signals are described as they relate to the on-board microcontroller, which is opposite the usual notation. The MOSI (master out, slave in) signal is actually the board’s data output, and MISO (master in, slave out) is the data input.

We tested the button pad with the Bus Pirate, but the same basic principals apply to any custom microcontroller code. The board runs at 5volts, so we powered it from the Bus Pirate’s on-board 5volt power supply. The SPI interface operates at 5volt logic levels, so we connected the Bus Pirate’s pull-up resistors to the 5volt power supply and enabled them on all signal lines.

We interfaced the button board using the Bus Pirate’s raw3wire library. Raw3wire is a software SPI library with bit-wise operations. The hardware SPI library only allows full byte operations which aren’t granular enough to interface the board. We put the Bus Pirate in raw3wire mode (menu option M), and chose the HiZ pin option because the pull-up resistors will hold the bus at 5volts.

RAW3WIRE>l <–configure bit order
1. MSB first
2. LSB first
MODE>2 <–least significant bit first
LSB SET: LEAST SIG BIT FIRST
RAW3WIRE>W <–enable power supply
VOLTAGE SUPPLIES ON
RAW3WIRE>

The button pad communicates least significant bit first, so we also configured the library to communicate LSB first. Finally, we hit capital ‘W’ to enable the Bus Pirate’s power supplies. The button board will flash each color momentarily as part of its power-on self-test.

Single/multiple button board setup

Each board needs to be configured for single or multi-board use. Boards come pre-programmed for single-board operation, but it might be a good idea to set the configuration anyways. The board configuration is permanently stored in EEPROM, so it only has to be done once.

RAW3WIRE>[\_ <--take all signals low
CS ENABLED <--CS enabled is 0volts
CLOCK, 0
DATA OUTPUT, 0
RAW3WIRE>

A special sequence places the board in configuration mode. Begin with all signal lines low (]\_).

RAW3WIRE>-^ 1 1 <–set single board operation
DATA OUTPUT, 1 <–data high
0×01 CLOCK TICKS <–one clock tick
WRITE: 0×01 <–config option 1, number of boards
WRITE: 0×01 <–set the number of boards
RAW3WIRE>w <–small ‘w’, power off
VOLTAGE SUPPLIES OFF
RAW3WIRE>W <–capital ‘W’, power on
VOLTAGE SUPPLIES ON
RAW3WIRE>

To enter configuration mode, take the data line high (-) and send one clock pulse (^), but leave chip select low. The board is now ready to accept configuration settings.

The first byte sent after entering configuration mode tells the board which setting to modify. Currently, only the number of boards can be configured (0×01). Next, send the number of connected boards, between 1 and 10. we sent 1 because we’re interfacing a single board. Reset the board and it will light a LED corresponding to the programmed number of boards.

Set colors and read button status

Now we’re ready to send color data to the board and read the button status. First, note that the CS (chip select) signal is opposite normal conventions. Usually CS activates a chip when the signal is low (0volts), and idles it when the signal is high (5volts); this is usually denoted by /CS, #CS, or !CS. Instead, the button controller is active when CS is high.

A 64byte transaction sets the LED colors and retrieves the button status. The first 16bytes program the red level for each LED, followed by 16bytes of green, and 16bytes of blue. Finish by reading 16bytes from the board to get the status of each button. Buttons data is sent as 0×00 if pressed, and 0xff if not pressed. The datasheet recommends a 400us delay between writing the color frames and reading the button data, but the Bus Pirate is slow enough that we won’t worry about that.

The protocol is simple enough, but there’s one major catch. The clock line must be high before raising CS, or the bytestream will be off by 1 bit. For this reason, many hardware SPI modules won’t work with the board.  This isn’t a problem if your microcontroller lets you twiddle pins that are controlled by a hardware module, but the micros we’ve worked with don’t allow this.

RAW3WIRE>/]255:16 255:16 255:16 r:16[
CLOCK, 1 <--clock must be high prior to raising CS
CS DISABLED <--CS to 5volts, opposite normal use
BULK WRITE 0xFF , 0x10 TIMES <--red LEDs
BULK WRITE 0xFF , 0x10 TIMES <--green LEDs
BULK WRITE 0xFF , 0x10 TIMES <--blue LEDs
BULK READ 0x10 BYTES: <--read button state
0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF
CS ENABLED <--CS to 0volts, opposite normal use
RAW3WIRE>

This command sets every color of each LED to full, and reads back the 16 button status bytes.

We first set clock high (/), and only then can we raise CS to 5volts (]) and begin the data transaction. 255:16 is a repeated command that sends the value 255  sixteen times. As each color channel has 8bits of intensity control, 255 is 100% on. We send 255 a total of 48 times, once for each color of each LED. Finally, we retrieve one 16byte frame of button data (r:16) and lower CS to end the transaction ([). The button values are all 0xff, indicating that no buttons are pressed.

RAW3WIRE>/] 0:16 0:16 128:16 r:16[
CLOCK, 1
CS DISABLED
BULK WRITE 0x00 , 0x10 TIMES
BULK WRITE 0x00 , 0x10 TIMES
BULK WRITE 0x80 , 0x10 TIMES <--all blue to 50%
BULK READ 0x10 BYTES:
0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF
CS ENABLED
RAW3WIRE>

Here, we set the blue level of every LED to 50% (128) and turn off all other colors. The button output now shows that button 0 is pressed.

RAW3WIRE>/] 0 0 0 0 255 255 255 255 0 0 0 0 0 0 0 0 0:16 0:16 r:16[
CLOCK, 1
CS DISABLED
WRITE: 0×00 <– red LED 0, off
… <–more of the same
WRITE: 0×00 <– red LED 3, off
WRITE: 0xFF <– red LED 4, 100% on
WRITE: 0xFF <– red LED 5, 100% on
WRITE: 0xFF <– red LED 6, 100% on
WRITE: 0xFF <– red LED 7, 100% on
WRITE: 0×00 <– red LED 8, off
… <–more of the same
WRITE: 0×00 <– red LED 15, off
BULK WRITE 0×00 , 0×10 TIMES <– all green LEDs off
BULK WRITE 0×00 , 0×10 TIMES <–all blue LEDs off
BULK READ 0×10 BYTES: <–read button status
0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF
CS ENABLED
RAW3WIRE>

This example shows how to address single LEDs. This time we actually write out all 16 bytes of the red color frame. Buttons 0-3 and 8-15 have a red value of 0 (red off), buttons 4-7 are set to 100% red (255). All green and blue LEDs are off (0, 0%).

Conclusion

It was really frustrating to get this board working because the first version of the datasheet had so many errors. SparkFun’s engineers and support were really helpful, and posted a corrected datasheet within days. As long as you have the updated datasheet, this is an easy board to work with.

We’d like to see a firmware update that eliminates the need to keep the clock signal high before raising CS. This quirk makes the board incompatible with many hardware SPI modules, leaving slow bit-bang routines as the only interface option. Fortunately, the source code is open and available to anyone who wants to make this change.

The button pad controller is a really neat board, and we look forward to using it in a future project.

Hack a Day review disclosure: We asked for a free board and SparkFun sent it to us. We had a terrible time getting it to work with the instructions in the first version of the datasheet, we documented that experience here.

Here’s another nerdy present that was built for Valentine’s Day. [João Silva] created a temperature sensing Munny. A Munny is a vinyl toy made to be customized. Other than these Munny speakers, we haven’t seen them in many electronics projects. The LM35CZ temperature sensor has an analog output that connects to the ADC on the ATtiny15L. The microcontroller changes the RGB LED’s color based on the temperature: blue for cold, green for comfortable, and red for hot. It only flashes every three minutes to conserve the power in the coin cells. His one-off circuit board also includes an ISP header for programming. The Munny’s head looks like it does a great job diffusing the light.

SparkFun has been selling button pad parts for some time and we used them in our RGB door lock project. A excellent part, but you needed to implement your own interface to use the boards. SparkFun has just released two additional versions to make it easier on builders. The first is their Button Pad Controller USB. It has a 4×4 grid of buttons lit by RGB LEDs and a USB interface. This board can be expanded using the Button Pad Controller SPI. The SPI bus means it should be easy to add the button pad to embedded projects. This newest release puts you much closer to building your own RGB monome clone or other custom controller than ever before. The unit pictured above is their own project and they have no plans on selling anything like it.

[John] has been working with several BlinkM RGB devices. He’s created a controller to talk to each of the BlinkMs wirelessly and change their behavior. The core is an old relay tester box used to test telephone circuits. Each of its four knobs are connected to the analog inputs on the Arduino. The signal is transmitted using RFlink devices. Each BlinkM is paired with an ATmega168 and receiver. The control box also has a switch to send the same signal to all of the devices at the same time. The transmit and receive code are available on his site. You can find a video of it embedded below.

[Garrett] took 30 of his ShiftBrite modules and mounted them to his front fence for Christmas. The ShiftBrite is a serially addressable high output RGB LED. The individual modules are quite adept at applications like this where you’re stringing multiple lights together. They have identical buses on either side, specifically for daisychaining. The installation above looks great.