The Luma Controller takes any audio input, calculates and analyzes a FFT of the spectrum, and sends commands out to a network of Luma nodes. This board duplicates the functionality of our music analysis software, but with greater flexibility and significantly less latency. The first prototype of the Luma controller is up and running and is built around an Arduino-bootloaded ATMEGA328. Although this board is functional and provides decent results, we are redesigning the controller from the ground up with a more powerful ARM processor.

The new Luma controller will be built around the STM32L100C6u6, a 32-bit microcontroller clocked at 33MHz. With a significantly faster clock rate and 12-bit (vs 8-bit) ADCs, we will get significantly improved performance.

We will also be adding WIFI connectivity, which will allow users to directly control algorithm parameters over the OSC protocol. We plan on implementing wifi with the CC3100 module from TI, which is currently unreleased. However, we are currently evaluating a pre-production chipset that is available from Newark. We will post more information when we have this board routed, fabricated, and in-house.

The next iteration of the Luma node has been fabricated and assembled! The new node incorporates 3 10W RGBW LEDs, controlled with constant-current buck drivers and an ATTINY2313 microcontroller. Like all Luma nodes, up to 32 nodes can be daisy-chaned and controlled over RS485 with our open-source music synchronization software. Support for DMX is nearly complete, and will be ready for use after some additional testing!

While developing the Luma RS485-networked LED driver we discovered a need for a small and inexpensive USB to RS485 adapter. We designed an adapter with a FTDI basic UART chip (FT230XS) and an inexpensive TI differential receiver (SN75176). Our small selection of parts brings the cost down to just over $5 for one adapter.

The adapter has a mini USB port and a surface-mount 8P8C (RJ45) jack. Two LEDs (RX and TX) are located on the left of the USB port, and a white power LED is located on the left of the RJ45 jack.

The RJ45 jack is DMX-compliant, and the solder-jumpers shown on the right of the RJ45 jack optionally connect pins 4 and 5 to +5v. Connecting these jumpers breaks DMX compliance, but allows you to power your custom projects from the bus. The transmit and receive enable lines on the differential transceiver are connected to the CBUS pins of the FTDI chip, allowing the FTDI chip to control transmit and receive enable automatically. The functionality of these pins is configurable with the FT-PROG utility. A sample configuration XML file is included in the sources below.

Sources

• ZIP with EAGLE brd/sch and gerbers
  

Development has started on the next version of the Luma RS485 high-power RGB LED driver node. The new Luma node will include a constant-current buck LED driver, PCB-mount LED, temperature sensor, 16MHz crystal,  and many other new hardware features–all in the same footprint. On the software side, we plan on adding DMX support in addition to extra LED fade routines and improved PWM resolution. Check back in the coming months for more updates!

More Luma development posts

Revision 3 Luma high-power RGB controller boards just got back from the fab, and we’ve populated and tested the first of the boards. The new boards include a 3-pin fan connector (power, ground, and tach) as well as improved thermal dissipation and support for both thru-hole and surface mount current-limiting resistors. The board is also slightly larger with mounting holes on each corner, a significant improvement from our old 3-hole mounting design.

Pulse Node

The Pulse node is a new member of the MNL family which is self-powered, incredibly small, and has 2 digital outputs for solid-state relays. Both of the ICs on this tiny node are placed on the bottom of the board directly under the RJ45 connectors. The node is powered over the CAT5 cable, eliminating the need for a DC power source at each Pulse node. Although the output capabilities of these nodes is fairly limited (2 channels can be switched on or off independantly with a single command) these nodes are great for driving solid-state relays which can control high-power flood lights, christmas lights, or any other AC device you can think of. The first revision of these boards needed a few green-wire fixes, but the second round should resolve all of the issues with the first design. Keep watching the blog for updates in the coming weeks.

Node Control and Protocol

We have made some updates to the MNL serial protocol to support addressing different types of nodes (such as Pulse or Luma) and we added the capability to reset the serial parser with a single magic byte. The Luma serial parsing engine is now much more robust, gracefully recovering from invalid bytes and unterminated commands. We also implemented additional color fade modes (static, dwell, fade, and strobe) and we’ve started to implement support for buffered RGB commands.

On the software side, we’ve updated our Processing application with support for OSC messages. This allows us to use a phone or tablet running TouchOSC (or any other OSC controller) to change fade mode, fade parameters, and music analysis parameters. Although we have relied on software to do audio analysis, we have begun designing the schematic of the new MNL node controller. This hardware controller will take the place of the Processing app in doing audio analysis, greatly reducing latency and allowing for standalone operation.

Moving Forward

In the coming months we will be exhibiting at the Detroit Maker Faire. If you’re in the area, come check us out to see a demo of our Pulse and Luma nodes in action. For more information about this event, check out makerfairedetroit.com.

http://www.makerfairedetroit.com/

MNL is a multi-node high-power RGB lighting system. It consists of a controller (PC or embedded system) and multiple light nodes networked with RS485. The first prototype nodes are up and running, and we will be developing the second revision of prototypes in the coming months. Read on past the break for more information.

Node Hardware

The node board is a small PCB with two RJ-45 ports and a power terminal strip, along with an ICSP header for flashing firmware. The nodes are designed for daisy-chaining both data and power.

Current features:

• RS485 communication
• Supports LEDs of up to 1.2A per channel
• Upgradeable firmware for additional features
• TBD: Firmware updates over RS485
• Multiple fade types, dwell modes, etc.
• Hardware-agnostic network supports different types of nodes (e.g., strobe, motor driver, etc)

LED Circuit

The LED used for prototyping is a 10W RGB LED from DealExtreme, which provides a generous amount of light with low cost per lumen. Although the heatsink is a bit small, forced-air cooling keeps things at a reasonable temperature.  The PCB includes a fan output which is PWMed according to the average instantaneous luminosity of the node. Forced-air cooling could be helpful for installation in compromising environments, such as can lighting fixtures.

The current design incorporates 3 current-limiting resistors for each channel of the LED. Although this is less efficient than current-regulated supplies, it allows flexibility in LED choice without requiring extensive PCB modifications.

Prototype Software

I developed a quick Processing sketch for testing purposes. It creates a FFT of the stereo mix and uses the lowest three bins to determine R/G/B brightness. If the largest of the three values is over the threshold specified by the slider, then an update command is sent to the node. The processing sketch also has an Open Sound Control (OSC) interface, allowing easy control from the TouchOSC app for iPhone or Android over WIFI as well as any software package that supports OSC.

This project is still under heavy development, and is still in the prototype phase. We are adding additional features to the software and hardware, so expect significant updates in the coming months.

tinyRGB is a minimalist blinkM-compatible high-current i2c RGB LED controller consisting of only 10 basic components. The board is small and inexpensive, can be fabricated for as little as $1/board, and can easily be assembled by hand with a total component cost of around $3.

tinyRGB runs the cyz_rgb firmware, providing a simple interface that is completely compatible with blinkM commands.

This board is designed to run on 5v, which is also exposed on the LED output header. However, this board can easily be used to drive LEDs at higher voltages by providing a higher voltage to the common cathode of the LED.

Parts:

• PCB [$1]
• Pin Headers (if desired)
• 3x 2N6427 1.2A / 40V NPN Transistor [$.04, mouser]
• ATTINY85 PDIP [$1.82, mouser]
• .1uF 0805 decoupling capacitor (optional) [$.06, mouser]
• 3x 0805 Surface-mount 1k resistors [$.04, mouser] (yes, you really can solder them with a fat wedge tip!)
• 3x current-limiting resistors matched to your LEDs

Total cost: ~$3, plus the cost of your LED and current-limiting resistors.

For firmware installation and setup instructions see the “build” section of Multi-Node Lighting.

Board and schematic downloads are included below. Note that the board is a bit rough around the edges (figuratively), and could use some improvement. Drop comments below if you have any suggestions.

Downloads:

• EAGLE Schematic
• EAGLE Board

I happened to scavenge a couple of SLG2016’s from some old workstation debug displays. After finally locating a datasheet, I realized that they used the standard ASCII charset, so they are extremely easy to drive. Note: The SLG2016 differs from the SLR2016, SLO2016, and SLY2016 only by LED color.

The only downside to these displays is that they use quite a few pins (7 data lines, 2 digit select lines, write line, and optional blanking line). For now, I’m driving the display with all pins in parallel on a tiny88 which has plenty of pins; however I plan on using a shift register to cut down on data bus pin usage in the future. The displays only need the data lines to be held stable during a write cycle, making shift registers well-suited to this task.

To flash the attiny88, I’m using a Bus Pirate (pictured above) flashed with the STK500v2 emulation firmware. This allows me to use avr-gcc with AVR Studio to program the chip.

Here is some code I used to test the displays, using PORTD for data lines, and the 2 LSB’s of PORTC for digit select lines. This is the first time I’ve worked with AVRs outside of the Arduino environment, so pardon any flagrant errors and drop me a comment if you have any suggestions.

#define F_CPU 1000000UL

#include <avr/io.h>
#include <util/delay.h>
#include <string.h>
#include <stdlib.h>

void wr();
void wrChar(char toWrite, int dig);
void wrWord(char *word);
void scrollWord(char *word);
void delay_ms(uint16_t ms);

int main (void){
  DDRC=0xFF;
  DDRD=0xFF;
  PORTD=0x00;
  PORTC=0x00;

  // Loop through a few strings for testing
  while(1){
    wrWord("Helo");
    delay_ms(500);
    wrWord("*?%$");
    delay_ms(500);
  }
}

// Toggle write pin (PC0)
void wr() {
  PORTD &= ~(1<<7);
  delay_ms(1);
  PORTD |= (1<<7);
}

// Write char to position
void wrChar(char toWrite, int pos){
  PORTC = pos;  // Set digit select lines
  PORTD = toWrite;  // Set data lines
  wr();  // Toggle write pin
}

// Write 4-char word
void wrWord(char *word){
  for(int i=3; i>=0; i--){
    wrChar(word[i], 3-i);
  }
}

// Generic delay function
void delay_ms(uint16_t ms) {
  while (ms) {
    _delay_ms(1);
    ms--;
  }
}