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--;
  }
}