Please stop talking about that thing in the desert

So, you’ve got yourself a reel of those gorgeous new pebble lights.

I don’t blame you! They are gorgeous. Coated in silicon, they are impervious to water and dust, nicely diffuse, and very flexible, so they can safely be used in costumes and stuff that will flex a lot. Each pebble is an individually-addressible 5V Neopixel (2812b), and seem happy with 3.3v data so you don’t need a level shifter.

They are, though, not a lot of fun to strip and solder. The stranded wires are thinner than anything you’ve ever seen. You might think you’ve got them soldered together, but the first bike ride at Burning Man and *blam* they fall apart, or short somewhere, or who knows what, but they just don’t work for very long and it’s your fault for soldering it wrong.

After hours trying everything I could to get the ends of these suckers onto JST connectors, I finally just designed a tiny circuit board to solve this problem.

The idea here is you can strip the wires, sploot them apart, and solder them onto copper pads on the PCBs which is much easier than soldering wires to wires. Then, you can put some heatshrink on top of the whole thing, which holds everything physically in place, prevents shorts, and protects against the elements.

Want to make some of these PCBs yourself? If you upload this gerber file directly to JLCPCB with all the default settings, they’ll make them and ship them to you.

If you want to customize something, here are KiCad files.

Here are detailed instructions.

Pre-solder the pads on the PCB

Separate the three wires from the pebbles

Use sharp scissors to start the separation, then pull the three wires apart with your fingers or needle-nose pliers.

Strip about 75% of the insulator

You are not going to be able to use wire strippers. Instead, make a tiny nick in the insulator by hooking it on your sharpest pair of scissors, then pull off the insulator using your fingernail.

Sploot out the three conductors

Here’s what it looked like under a microscope:

Notice that the bottom conductor (when the pebble is facing up) has one or two strands of copper-colored wire in there. This is the 5V conductor. The one in the middle is data, and the remaining conductor is GND.

Solder

Place the three stripped wires above the pads on the PCB. With your soldering iron, heat each of the wires for a few seconds. Once they heat up they will melt the solder below them on the pad and sink into the solder. Add a couple more drops of solder on top.

One of the pebbles will land on top of the PCB. That is intentional! We are going to sacrifice that pebble by covering it in heat shrink, which will create much more physical strength than we could get from the solder joints alone.

Solder the other side

Repeat on the other side. You might want to use a JST-SM 3-pin connector which is pretty standard in LEDs, or any other connector you like. You can also find reels of 3-conductor, 22awg “LED wires” online if you need a few more feet.

Heatshrink

Find some heatshrink that is 1/2″ diameter, about an inch long. Look for heat shrink with a 4:1 shrink ratio that is adhesive lined, dual-wall. Slip this over the whole PCB and heat.

And you’re done!

Notice that one of the pebbles has disappeared beneath the heat shrink, but that’s worth it, because it provides a little lump that makes the whole joint stronger.

One of the biggest hassles with addressable LED strip installations is that you usually end up running data and power separately. Sure, in theory, a Neopixel type installation just needs three conductors – one for data, one for ground, and one for +5V or +12V. In practice this doesn’t work on large installations for two reasons:

1. If the first pixel is too far away from the controller, the quality of the data signal degrades quickly. After a few feet, you are likely to see glitches.
2. You need fairly chunky cables to avoid voltage drop in the power cable. Most LED strips, in fact, have so much voltage drop in the strip themselves that you can only run about 300 pixels before you have to re-inject power.

Last year, I created a big (40′) LED antenna so I could find my way home at Burning Man. I solved the first problem by using differential signaling (RS-422), and the second problem by injecting power every 300 pixels. It looked and worked great:

The trouble was all the cables. I had CAT-5 cables (I used the flat kind) going to each strip with the data, then I used heavy 14awg speaker wire to inject power. As you can see here, the amount of cable (and its complexity) were not insignificant:

I wasn’t really happy with this solution and finally thought, dammit, I’m gonna just run power AND signal over one frigging ethernet cable, I don’t care if you say it’s impossible.

Well, I’m here to report that it’s not impossible. CAT-6 comes with four twisted pairs. I’m using one of the pairs for RS-422 differential signaling. Then I use three of the remaining wires for GND and three for +12V.

I chose CAT-6 because it is available in 23awg, which seems to be the thickest copper you can get in ethernet cabling. At that gauge, there is still some voltage drop. Over about 75 feet, which is the longest you wanna go, you will see a voltage drop from about 12 volts to under 10 volts. That is still within the range that can power a WS2815 strip with 300 pixels happily. I actually plan to plug this into Mean Well power supplies which allow you to juice up the volts to about 13.8 at the origin.

Now, as you can see from the picture of the antenna, my obsession is not having a lot of messy cables or circuitboards up near the base of the LED strips. So I designed this cute little circuit board:

It’s slim enough that you can just heat shrink it and it will basically disappear in between your LED strip and your CAT-6 cable. It has three functions:

1. Collect the power from 6 wires and send it to the LED strip
2. Decode the differential signal using a MAX485 chip (this is powered using a basic 12V to 5V voltage regulator)
3. Three capacitors on the right handle power surges from the LED strip so you can make epileptic flashing white strobes to your heart’s content (not tested).

Here’s a schematic:

These things cost me about $5 each plus shipping to get made in China (including the PCB board, assembly, and all the parts).

In the end I’m psyched that every LED strip in my project will have one simple CAT-6 of exactly the right length going back to my project box!

_{^{Updated 20 April, 2024}}

Got a Teensy 4.1? Want to use it with FastLED? You’ve come to the right place. The Teensy 4.1 is an incredibly powerful microcontroller at a very reasonable price, and FastLED is still one of the best libraries for driving WS2812 type addressable LEDs from microcontrollers.

Paul Stoffregen, creator of Teensy, has a library called OctoWS2811 that provides fairly basic operations to send RGB data out to addressable LEDs. Unlike FastLED, it doesn’t have all the fancy color manipulation, palettes, fast math operations, etc… just basic “set the pixel color” type operations. But OctoWS2811 is blazingly fast and works perfectly on the Teensy 4.1. One of the reasons it is so fast is because it can drive strips using any and all GPIO pins in parallel and without using a lot of CPU time. (More about my experience here).

So what you really want to do is combine OctoWS2811 with FastLED and you will be cooking with fire. Here’s how to do that.

Step one – get the latest version of OctoWS2811 from GitHub. (Make sure you have version 3.5). The only two files you’re going to need are OctoWS2811.h and OctoWS2811_imxrt.cpp so just add those to your project.

You can use OctoWS2811 directly to write to the LEDs. Here’s an example using 8 pins, numbered 33-40 (this code goes in your main.cpp or .ino file):

  const int numPins = 8;
  byte pinList[numPins] = {33, 34, 35, 36, 37, 38, 39, 40};
  const int ledsPerStrip = 300;
  CRGB rgbarray[numPins * ledsPerStrip];

  // These buffers need to be large enough for all the pixels.
  // The total number of pixels is "ledsPerStrip * numPins".
  // Each pixel needs 3 bytes, so multiply by 3.  An "int" is
  // 4 bytes, so divide by 4.  The array is created using "int"
  // so the compiler will align it to 32 bit memory.
  DMAMEM int displayMemory[ledsPerStrip * numPins * 3 / 4];
  int drawingMemory[ledsPerStrip * numPins * 3 / 4];
  OctoWS2811 octo(ledsPerStrip, displayMemory, drawingMemory, WS2811_RGB | WS2811_800kHz, numPins, pinList);

Now to hook this up with FastLED, you create a custom FastLED “controller” which just forwards the bits to OctoWS2811. This is the simplest possible FastLED controller; it looks like this (put this in a file called teensy4controller.h and #include that from your main file).

#include <OctoWS2811.h>
#include <FastLED.h>
#include <Arduino.h>

template <EOrder RGB_ORDER = RGB,
          uint8_t CHIP = WS2811_800kHz>
class CTeensy4Controller : public CPixelLEDController<RGB_ORDER, 8, 0xFF>
{
    OctoWS2811 *pocto;

public:
    CTeensy4Controller(OctoWS2811 *_pocto)
        : pocto(_pocto){};

    virtual void init() {}
    virtual void showPixels(PixelController<RGB_ORDER, 8, 0xFF> &pixels)
    {

        uint32_t i = 0;
        while (pixels.has(1))
        {
            uint8_t r = pixels.loadAndScale0();
            uint8_t g = pixels.loadAndScale1();
            uint8_t b = pixels.loadAndScale2();
            pocto->setPixel(i++, r, g, b);
            pixels.stepDithering();
            pixels.advanceData();
        }

        pocto->show();
    }
};

To use this new controller:

#include "teensy4controller.h"

CTeensy4Controller<RGB, WS2811_800kHz> *pcontroller;

void setup()
{
    octo.begin();
    pcontroller = new CTeensy4Controller<RGB, WS2811_800kHz>(&octo);

    FastLED.setBrightness(255);
    FastLED.addLeds(pcontroller, rgbarray, numPins * ledsPerStrip);
}

Tip: This works for Teensy 4.0, too.

Sample code to get started (for VSCode + PlatformIO)

Another tip: You can use any and all pins in any order. Just change numPins and pinList.

Update (Nov 2024) – there is a library called ObjectFLED which gets you all of the same benefits as this technique, but also lets you configure each pin individually, so if you have different lengths and types of LEDs it can handle that.

Enjoy!

For the future Turtle Antenna, I’m using 16 of these “flex led” strips. Each strip is 5 meters of WS2815 in a nice IP68 frosty silicone sleeve which creates beautiful, diffuse pastel colors. They are 60 pixels per meter so I’m using a total of 4800 LEDs.

If you asked me a year ago I would have said that this year I’d be using ESP32s as controllers.

Teensy 4.1 is a game changer.

Here I’m running:

• 4800 LEDs (WS2815b)
• 107 frames per second
• 16 strips, in parallel, each on their own pin
• RAM used 111284 bytes (21%)
• CPU load: negligible
• Peak AC power consumption (full white) 500 watts / 6amps
• For each WS2815b strip of 300 12v LEDs, I am only injecting power once at the bottom.

The prototype breadboard here shows one Teensy 4.1, two level shifters (8 strips each), and four RS422 encoders (4 strips each). Then I drive the signal over CAT5 to a tiny RS422 decoder board. The whole RS422 thing is not necessary if your controller is within about 5m of your strips. I haven’t tried going further but I would not be surprised if you could run 20,000 pixels at 60fps off of one Teensy 4.1…. without using any kind of shift register or extra hardware.

I have been experimenting with various ways to build power injection cables for long runs of LEDs that will be outdoors in suboptimal conditions. Here’s what I came up with, all using parts easily procured from Amazon.

This is the power supply I chose. I like it because it is already reasonably weatherproof. I have also heard very good things about Meanwell power supplies, like the LRS-350-12, but that needs to be put in a box and you would need to wire up your own AC cable.

I found this cool tool for removing the outer jackets. If you’re following along with me, strip 5/8″ of the outer jacket.

Then strip the wires to 1/4″:

Then I crimped on these cute things. I think they are called ferules? “Insulated Bootlace Ferules,” I am told. Anyway, they make it safe to connect the stranded cable to a screw terminal.

Next, get these outdoor “junction boxes.” They come in 2 way and 3 way versions. They have cable glands on both ends which make a watertight seal as long as you use cable with a circular cross-section.

Here’s a 2 way connector, exploded:

Stick the wire through…

Technically these things have three internal connectors. I only use two for power injection. But if you are also sending WS2812 data, the third post is available.

Now you need to choose what kind of cable you are going to use for your power injection cable.

Use an online voltage drop calculator to figure out what gauge you need. This depends on whether your LEDs are 5v or 12v. If you are already building power injection cables, it sounds like you are planning long runs of power. In that case you will be much happier with 12v LEDs like ws2815.

In my case, and with a lot of testing, I decided 14awg was enough. I bought this speaker cable, but be warned: because this cable has a “slip sleeve” instead of a perfectly circular moulding, it will not make a watertight seal with the cable glands! That is OK for my application but if you want something watertight, find a circular cable.

Next:

The junction boxes are available as T’s, which is what I used at each power injection point. This is a female two-conductor “Ray Wu Connector” which powers a single LED strip that came from the factory with a male two-conductor connector.

Ferrules! Cute as a button!

Here ‘s the whole thing before screwing together?

Here are two complete assemblies.

In my situation each power supply powers 4 five-meter strips; each strip has 300 pixels at 12v.