Build a Bluetooth‑Enabled Smart Lamp from Scratch

Ever walked into a dark room, fumble for the switch, and wish the light could just know what you need? The pandemic taught us that home offices are here to stay, and a lamp that you can dim, change color, or set on a timer from your phone feels less like a luxury and more like a sanity‑saver. Let’s turn that wish into a weekend project.

Why a DIY Smart Lamp?

Off‑the‑shelf smart bulbs are convenient, but they come with a few quirks: they’re pricey, you lose the tactile feel of a real switch, and you’re stuck with the manufacturer’s app ecosystem. Building your own lamp gives you three big wins:

Cost control – you buy exactly what you need, no hidden markup.
Full customization – choose the LED strip, the housing, even the voice command you prefer.
Learning by doing – you’ll end up with a deeper grasp of how Bluetooth Low Energy (BLE) talks to microcontrollers, and that knowledge pays off in future projects.

What You’ll Need

Hardware

LED strip – 5 V or 12 V WS2812B (the “NeoPixel” type) works great for color control.
Microcontroller – an ESP32 is my go‑to because it has built‑in Wi‑Fi and BLE, plus plenty of GPIO pins.
Bluetooth module – optional if you pick a board without BLE; the HM‑10 is a cheap fallback.
Power supply – a 5 V 2 A USB‑C wall adapter for a 5 V strip, or a 12 V 2 A supply for a 12 V strip.
Switch – a simple momentary push button for manual on/off.
Enclosure – a 3D‑printed lamp shade or a repurposed glass jar; I used a matte‑finish acrylic cylinder.
Miscellaneous – heat‑shrink tubing, solder, wire strippers, a small breadboard for prototyping.

Software

Arduino IDE – free, cross‑platform, and supports ESP32 out of the box.
FastLED library – handles the timing‑critical communication with WS2812B LEDs.
BLE peripheral sketch – a short program that advertises a custom service for brightness and color.

Wiring the LED Strip

Start on a breadboard. Connect the +5 V (or +12 V) line of the strip to the power supply’s positive output. The ground of the strip, the ESP32, and the power supply must all share a common ground – this prevents flicker and protects the microcontroller.

The data line of the WS2812B goes to any ESP32 GPIO that supports output; I used GPIO 18 because it’s hardware‑PWM capable, which helps with smooth dimming. Insert a 470 Ω resistor between the ESP32 pin and the LED data line – it damps voltage spikes and improves reliability.

If you’re using a 12 V strip, add a logic‑level shifter (5 V to 12 V) before the data line. The WS2812B chips themselves run on 5 V, but the strip’s power rails are higher.

Adding Bluetooth

The ESP32’s BLE stack is ready to go, so you don’t need a separate module unless you’re on a cheaper board. In the Arduino sketch, define a custom service UUID (a 128‑bit identifier) and two characteristics: one for brightness (0‑255) and one for color (RGB packed into a 24‑bit integer). When a phone app writes to these characteristics, the ESP32 updates the LED strip in real time.

If you prefer a ready‑made app, the “nRF Connect” app on Android and iOS lets you discover the service, write values, and even set up notifications for status feedback.

Programming the ESP32

Here’s the skeleton of the code (no need to copy‑paste; it’s just to illustrate the flow):

#include <FastLED.h>
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>

#define LED_PIN     18
#define NUM_LEDS    30
CRGB leds[NUM_LEDS];

BLECharacteristic *brightChar;
BLECharacteristic *colorChar;

void setup() {
  FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
  FastLED.clear();
  FastLED.show();

  // BLE init
  BLEDevice::init("SmartLamp");
  BLEServer *server = BLEDevice::createServer();
  BLEService *service = server->createService("12345678-1234-5678-1234-56789abcdef0");
  brightChar = service->createCharacteristic("abcd", BLECharacteristic::PROPERTY_WRITE);
  colorChar  = service->createCharacteristic("efgh", BLECharacteristic::PROPERTY_WRITE);
  brightChar->setCallbacks(new BrightCallback());
  colorChar->setCallbacks(new ColorCallback());
  service->start();
  BLEAdvertising *adv = BLEDevice::getAdvertising();
  adv->addServiceUUID(service->getUUID());
  adv->start();
}

void loop() {
  // Nothing needed here – callbacks handle updates
}

The BrightCallback and ColorCallback classes simply read the incoming value and call FastLED.setBrightness() or fill_solid() respectively, then FastLED.show(). The whole thing runs on a 240 MHz ESP32 core, so latency is barely noticeable.

Enclosure and Finishing Touches

Once the circuit works on the breadboard, solder everything onto a small perf board. Keep the power wires short to avoid voltage drop, especially with longer LED strips. Mount the ESP32 on the board, then slide the board into the lamp housing.

I printed a diffuser ring with a 3‑mm layer height to soften the LED glare. A tiny magnetic base lets the lamp sit on a metal desk without a permanent footprint – handy for renters.

Don’t forget heat management. Even though WS2812B LEDs are efficient, a 30‑LED strip can run a few watts at full white. A small aluminum heat sink clipped to the perf board keeps the ESP32 from throttling.

Testing and Tweaking

Power up the lamp and open the BLE app. Slide the brightness slider – you should see the light respond instantly. Change the color picker; the LEDs should transition smoothly thanks to FastLED’s built‑in dithering.

If you notice flicker, double‑check the ground connections and make sure the data line resistor is in place. A common hiccup is voltage sag when the strip draws a lot of current; a capacitor (1000 µF, 6.3 V) across the supply rails smooths that out.

For a final polish, add a software watchdog that resets the ESP32 if it loses BLE connection for more than 30 seconds. That way the lamp recovers gracefully after a phone reboot.

What I Learned

Building this lamp reminded me why I love DIY: you get to pick each component, understand the trade‑offs, and end up with something that feels truly yours. The ESP32’s BLE stack is surprisingly straightforward, and FastLED abstracts away the timing nightmare of WS2812B LEDs. The biggest surprise? The lamp’s manual button still feels satisfying – sometimes you just want to flip a switch without pulling out your phone.

If you’re new to soldering, start with a short LED strip and a single color. Once you’re comfortable, expand to multiple zones, add a motion sensor, or even integrate with Home Assistant for voice control.

Happy tinkering, and may your evenings be bright, programmable, and free of accidental midnight trips to the light switch.

#smartlamp #diy #bluetooth