iLED: Interactive Light Tiles

Overview of the Basic LED Panel
(see diagram below)

LED Control
Each LED panel will be 1' x 1' and have a resolution of up to 24x24 RGB LEDs connected in a common anode matrix configuration. This means we will need 24 high side drivers and 24*3=72 low side drivers per board meaning a total of 24+72=96 connections from the LED array to the FPGA. The FPGA will implement 72 PWMs on the low side drivers and scan the board row by row to allow variable brightness of each channel of every LED.

Interface
Each 1' x 1' board will have a set of DIP switches to set its address in the wall. The FPGA will have an address bus and a data bus allowing the master controller to control each LED. The address bus will be used to specify the board address as well as an R/G/B channel of an LED on that board. The data bus will be used to specify the brightness of the LED.

The FPGA will also need to read input from various sensors on the board and send this information back to the master controller. We will need to determine whether the sensor data will use a separate bus or if it will be integrated with the LED control bus.

[TODO: determine bus details]

Power
Assuming an average LED current of 10mA, a fully illuminated board of 24x24 RGB LEDs will require 24*24*3*0.01A=17.28 Amps per board, not including FPGA and sensor power. Each board should have a power supply capable of 20A.




Resources

LEDs:

Soldering Info:

LED Info:
http://members.misty.com/don//ledx.html

Useful hardware:
Color sensors: HDJD-S722/ADJD-E622 color sensor produced by Avago Technologies
Maxim MAX6965 (LED Driver Chip)
16-to-1 analog MUX (DG 706)


(Below) This is a different project on Touch-sensitive LEDs. It has some useful links. This is not the focus of our senior design project.

Touch-sensitive LEDs: Project Overview
LEDs have normally been used only to emit light. However a little used capability is that they can detect light too. Just as ordinary diodes, if we reverse the bias, a small leakage current is observed across the LED. When light shines on an LED, it acts as a photo-sensitive diode and emits a small current. This enables use to make LED arrays that are light-sensitive and touch-sensitive. The idea is to eventually make 2'x5' LED panels with hundreds of LEDs that are illumination, touch, motion and sound sensitive - so different glow patterns are triggered when a person passes by the LED wall or interacts by touch or sound with The Wall.

So what is the use? First, it is cool :), second it is interactive, and third (where the research is) is that we can use it as a visualization tool. For example, if we have a real sensor network with hundreds of nodes, it is very difficult to "see" what is going on in each node. By using the LED Wall we can simultaneously simulate the sensor network routing schemes and see how the data disseminates across thousands of nodes, display which nodes are getting too much traffic, which have dying batteries, etc. So think of it a generic visualization system for large scale data - so the major problem then is how do we program 1000s of nodes and what programming abstractions work best? Finally, this is a serious project as the number of I/O lines is huge and making such a system will require some serious hardware hacking skills.

1. Getting Started
The first step is to first fully understand what I have in mind. Then we brainstorm and pool our ideas to decide on what The Wall will eventually become. So here are some links on very cool projects that use this idea, some links on building such circuits and three papers with more details. We do not want to just copy them but make an original system where we intersperse different sensors (e.g. microphones) in the LED array and output a visualization based on the sensor fusion.

Interesting Links:
a) Lightspace : Interactive LED Tile System - they use "tiles" but we can just use tri-colored LEDs for more fine-grained response
http://futurefeeder.com/index.php/archives/2005/06/13/lightspace-interactive-led-tile-system/

b) Click on Products and look at the videos
http://www.lightspacecorp.com/

c) This is an early version of the company. It started as a fun student project :)
http://www.dropoutdesign.com/

d) Picture Frame Tetris - check out the video
http://www.sparkfun.com/commerce/present.php?p=Tetris

e) monome - A Philly LED-Music company
http://monome.org/

f) Sample Circuits - note LED photo sensor and Touch-Activated Light
http://ourworld.compuserve.com/homepages/Bill_Bowden/page8.htm#light.gif

Some tutorials and papers:
a) LEDs as Sensors
    http://projects.dimension-x.net/technology-and-projects/ledsensors

b) Using Light Emitting Diode Arrays as Touch-Sensitive Input and Output Devices - a very clear and basic explanation of how to design a touch-sensitive array
    [PDF]

c) Very Low-Cost Sensing and Communication Using Bidirectional LEDs - a more detailed explanation on the concepts behind the magic
   [PDF]

d) A class project [DOC]

2. Play
We'll make some mini test circuits on a breadboard and a microcontroller to verify/play with our ideas and understand how we can control and actuate single LEDs. We can buy whatever parts we need.

3. Hardware Hacking 101
Now we get into some more serious stuff - making a programmable LED Wall. As you will learn quickly see we have a huge problem with I/O and power lines as each Tri-colored LED requires at least 5 signal/power lines. Now extend that to 100 LEDs and that is 500 lines on a small board. One way to attack this is to use an FPGA which has several GPIO lines. The second way is to use hierarchy in our wiring where a wall panel is made of different zones and each zone is composed of multiple arrays. A zone can be FPGA controlled and an array can be microcontroller controlled. We will need to define and implement a control/data bus for the FPGA to control multiple microcontrollers.

4. Prototype Gen 1: The first mini-panel
Here we will design our first panel with 100 LEDs and trigger different lines based on sensor outputs.


5. Programming 1000 LEDs: Interaction and Reflection
Now we get into some real embedded systems where we design a software framework to run across the set of FPGAs and tens of microcontrollers. How do we program such a beast? Can we do it over wireless? How do we create algorithms to display different visualization patterns?


6. Network Protocol Visualization on The Wall
This is one of the uses of the panels. If we have a real sensor network with hundreds of nodes, it is very difficult to "see" what is going on in each node. By using the LED Wall we can simultaneously simulate the sensor network routing schemes and see how the data disseminates across thousands of nodes, display which nodes are getting too much traffic, which have dying batteries, etc.




------------------------ To be filled in at a later point in time ------------------------
Goal:

A. Overview

1. Sensing:

2. Virtual Sensing

3. Response

B. Applications

C. Research Component

D. Implementation

E. References