DIY Tower Stack Light with Smart Home Integration

Ever walked past a factory floor or a server rack and thought, “That blinking tower could be my next weekend project?” In 2024 the buzz around smart lighting isn’t just for living rooms – hobbyists are turning ordinary LED strips into eye‑catching tower stack lights that talk to Alexa, HomeKit, or even a simple MQTT broker. If you’ve ever wanted a visual cue for your home automation events (like “mail delivered” or “garage door open”) this guide will walk you through building one from scratch, step by step.

Why a Tower Stack Light?

A tower stack light is more than a pretty flash. In industrial settings they signal machine status – green for go, amber for warning, red for stop. At home you can repurpose that language: green when the washing machine finishes, amber when the front door is ajar, red when a smoke alarm triggers. The visual feedback is instant, even if your phone is on silent. Plus, building it yourself gives you the satisfaction of soldering, programming, and tweaking the look to match your décor.

Parts List

Before you start, gather these items. All of them are easy to find on Amazon, local electronics stores, or a hobby shop.

• LED modules – 5 V or 12 V WS2812B addressable strips (the kind that let you set each pixel’s color). I like the 5 m roll; you’ll only need a short section.
• Microcontroller – ESP8266 (NodeMCU) or ESP32. The ESP32 gives you more pins and built‑in Bluetooth, but the NodeMCU is cheaper and works fine.
• Power supply – 5 V 3 A wall adapter (or 12 V if you chose 12 V LEDs). Make sure it can handle the total current; each WS2812B LED draws up to 60 mA at full white.
• Resistors – 330 Ω for the data line, 10 kΩ pull‑down for the reset pin (optional but good practice).
• Capacitor – 1000 µF, 6.3 V electrolytic across the power rails to smooth spikes.
• Mounting hardware – aluminum extrusion (the kind used for 3‑D printer frames), brackets, and a few M3 screws.
• Wiring – 22‑AWG stranded wire, heat‑shrink tubing, and a small breadboard or perf board for connections.
• Tools – soldering iron, wire cutters, multimeter, and a drill if you need to make holes in the extrusion.

Step 1: Design the Frame

I started my first tower light by repurposing a spare 2020 aluminum extrusion from a 3‑D printer. It’s sturdy, lightweight, and the slots make it easy to slide in brackets. Measure the height you want – 24 inches works well for a kitchen counter, 36 inches for a garage wall. Cut the extrusion to size with a hacksaw or a miter saw, then drill two holes near the top and bottom for mounting brackets.

Tip: Keep the frame hollow so you can run the power cable through the inside. It looks cleaner and protects the wires from accidental snagging.

Step 2: Wire the LED Strip

Strip the LED tape to expose the copper pads. Solder a short length of wire to the +5 V, GND, and Data pads. Add the 330 Ω resistor in series with the data line – it protects the first LED from voltage spikes. Then, on the power side, solder the 1000 µF capacitor across the + and – rails. This capacitor is a lifesaver; without it the LEDs can flicker when the microcontroller draws power.

Safety note: Double‑check polarity. Reversing the power leads can instantly kill the strip.

Step 3: Connect the Microcontroller

Plug the ESP board into a USB cable and flash it with the Arduino IDE. Use the FastLED library – it’s simple and well‑documented. Here’s a minimal sketch to get the tower blinking green, amber, and red in a loop:

#include <FastLED.h>

#define LED_PIN    5
#define NUM_LEDS   30
#define BRIGHTNESS 128
CRGB leds[NUM_LEDS];

void setup() {
  FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
  FastLED.setBrightness(BRIGHTNESS);
}

void loop() {
  fill_solid(leds, NUM_LEDS, CRGB::Green);
  FastLED.show();
  delay(2000);
  fill_solid(leds, NUM_LEDS, CRGB::Orange);
  FastLED.show();
  delay(2000);
  fill_solid(leds, NUM_LEDS, CRGB::Red);
  FastLED.show();
  delay(2000);
}

Upload the code, then disconnect the USB and feed power from the 5 V adapter into the VIN and GND pins. The ESP will now run off the same supply as the LEDs.

Step 4: Add Smart Home Connectivity

The fun part is making the tower respond to events. I prefer MQTT because it works with Home Assistant, OpenHAB, and even simple scripts. Install the PubSubClient library and replace the loop() with a subscriber that listens for a topic like home/stacklight.

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

const char* ssid = "your_wifi";
const char* password = "your_pass";
const char* mqtt_server = "192.168.1.100";

WiFiClient espClient;
PubSubClient client(espClient);

void setup_wifi() {
  delay(10);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }
}

void callback(char* topic, byte* payload, unsigned int length) {
  String msg;
  for (unsigned int i = 0; i < length; i++) {
    msg += (char)payload[i];
  }
  if (msg == "green") {
    fill_solid(leds, NUM_LEDS, CRGB::Green);
  } else if (msg == "amber") {
    fill_solid(leds, NUM_LEDS, CRGB::Orange);
  } else if (msg == "red") {
    fill_solid(leds, NUM_LEDS, CRGB::Red);
  } else if (msg == "off") {
    fill_solid(leds, NUM_LEDS, CRGB::Black);
  }
  FastLED.show();
}

void reconnect() {
  while (!client.connected()) {
    if (client.connect("stacklight")) {
      client.subscribe("home/stacklight");
    } else {
      delay(5000);
    }
  }
}

void setup() {
  // previous LED setup code …
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
}

Now any automation that can publish to home/stacklight will change the tower’s color. In Home Assistant, a simple automation could look like:

- alias: Mail Delivered Light
  trigger:
    platform: state
    entity_id: sensor.mailbox
    to: 'on'
  action:
    service: mqtt.publish
    data:
      topic: home/stacklight
      payload: green

That’s it – your tower now flashes green when the mailbox sensor flips.

Step 5: Mount and Finish

Slide the LED strip into the extrusion’s slot, route the power cable through the hollow center, and secure the ESP board on a small mounting plate at the base. Use heat‑shrink tubing on all exposed solder joints – it looks neat and prevents short circuits.

Give the tower a final test by sending a few MQTT messages from your phone or a command line. If everything works, tighten the brackets, plug the power adapter into a wall outlet, and step back. You’ve just turned a pile of LEDs into a smart visual notifier.

Troubleshooting Quick Tips

• Flickering LEDs: Check the capacitor and make sure the power supply can handle the current. Adding a second 5 V adapter in parallel can help for longer strips.
• No MQTT response: Verify the ESP is connected to Wi‑Fi (the built‑in LED will blink during connection). Also confirm the broker IP and port are correct.
• Wrong colors: WS2812B strips use GRB order, not RGB. The FastLED library defaults to GRB, but if you use a different library you may need to swap the order.

Personal Note

My first tower light was a clunky prototype built on a coffee table with a cheap clone ESP8266. It sparked (literally) a whole weekend of soldering, a few burnt fingers, and a lot of “why does it only show red?” moments. The breakthrough came when I added that 1000 µF capacitor – the LEDs stopped flickering and the whole thing felt solid. Since then I’ve installed three more towers around the house: one in the workshop to signal CNC job completion, another in the pantry for “low supplies” alerts, and a third in the hallway that glows blue when the front door locks. Each one started as a simple DIY project, but they’ve become part of my daily routine.

If you’re new to smart home tinkering, start small. A single tower light is a great entry point, and you can expand it as you get comfortable with MQTT and ESP programming. The satisfaction of seeing a flash of green because your coffee maker finished brewing is worth every solder joint.

Happy building, and may your stack lights always stay green when they should!