Tools & Tech / September 2018

Exploring LED Lights at Large Scale

Our team recently installed a digital donor wall for Thomas Jefferson University’s new Alumni Center, featuring a digital display connected to a physical wall of donor names. As you explore and search using the digital interface, the names of donors light up, showing the legacy that individuals have across generations, classes, and schools.

This project with Jefferson University was an opportunity for our team to explore LED lighting at a large-scale—nearly 10,000 individually programmable lights. During this project, we had to consider solutions to problems that you don’t typically encounter when thinking about LEDs on a scale of tens or hundreds of lights. For this project to be successful, not only did the project have to be functional and beautiful, but also easily programmable by non-technical staff in the future.

Prototyping the problem

The path to our final solution required lots of trial and error. We explored networking Arduinos and Raspberry Pis with various arrangements of breadboards and wiring to the LED strips. We explored several types of LED types, including Adafruit’s NeoPixel and DotStar strips. And, after several workshop days, progressively scaling up these systems from a single strip to dozens of strips, we quickly realized we needed a better, scalable solution.

two people at a table soldering

Cue FadeCandy.

The FadeCandy driver was built for this type of project. Created by ScanLime and Adafruit, FadeCandy is a piece of hardware and software combined that supports building projects with LEDs. You can find extensive examples and documentation on GitHub about FadeCandy. There are other solutions similar to the FadeCandy driver out there, but it is open source and well-documented—two key things we look for in our projects.

Getting a FadeCandy up-and-running is simple, but scaling it up to many LEDs can be a challenge. We used a tutorial online that describes wiring up 1,500 LEDs to create a flexible curtain (you can find this tutorial on Adafruit), but our solution needed to support nearly ten times that amount of pixels.

From prototype to solution

To understand how we scaled up, it’s important to know how the wall was structured.

TJU Networking Schematic

The full donor wall was twenty feet long, broken into six 40-inch individual panels to make it easier to fabricate and install in the space. Coincidentally, this is almost exactly the length of a one-meter strip of LEDs. Each panels support 32 strips of LEDs controlled by four FadeCandy drivers (20 in total), which meant that we would need 160 one-meter strips, totaling 9,600 individual LEDs. We opted for the NeoPixel 60-LED per meter option—less LEDs didn’t provide a nice enough glow behind the individual donor names, but scaling up to 144 pixels would increase our power requirement by nearly 2.5 times.

list of names lit by an LED strip

The longest distance between a FadeCandy and the computer was approximately 20 feet, considering routing cables around corners and keeping things tidy. It was important to purchase active USB cables so we could ensure adequate power was running to the FadeCandy boards from the USB hub, and we used a Sipolar 20-port USB hub to connect our FadeCandys to the computer. Each FadeCandy was housed in a custom, 3D printed enclosure to keep them safe and mountd to the wall.

Power was our next challenges. Each FadeCandy was wired with eight 2-pin JSTs so we could attach them directly to the LED strips (and make replacing any part easier in the event of failure), and each strip was wired with their existing 5V power and ground to a custom header bar attached to a Mean Well 600W 5V 120A Power Supply—more power than was necessary, even if all of the LEDs were turned on (thanks to the team at Art Guild for their help with this step).

Once everything was wired, it was time to turn on some lights.

Programming the lights
A man at a laptop programming LED strips

Mapping the FadeCandys in sequence was the most time consuming part, ensuring the strips were in sequence so they light up as expected.

{
    "listen": ["127.0.0.1", 7890],
    "verbose": true,
    "color": {
        "gamma": 2.5,
        "whitepoint": [1.0, 1.0, 1.0]
    },

    "devices": [
        {
            "type": "fadecandy",

            "serial": "XXXXXXXXXXXX",
            "map": [
                [ 0, 0, 0, 60 ],

[ 0, 60, 64, 60 ],

[ 0, 120, 128, 60 ],

[ 0, 180, 192, 60 ],

[ 0, 240, 256, 60 ],

[ 0, 300, 320, 60 ],

[ 0, 360, 384, 60 ],

[ 0, 420, 448, 60 ]
            ]
        },

       {

...

       }
    ]
}

After everything was mapped properly, it was easy to run the FadeCandy server using fcserver config.json and run the built-in utility to turn the lights on and off for each driver to test them. There are plenty of ways to work with the FadeCandy from here (examples are available in many languages on the GitHub repository).