Designing Your Own Smart Light PCB: A Step-by-Step Guide

Ever tried to dim your desk lamp with a swipe on your phone and ended up wrestling with a clunky off‑the‑shelf module? I’ve been there. The good news is you can build a sleek, custom controller that fits your desk, your style, and your budget. Below is the exact path I followed last summer when I decided my roommate’s habit of flipping the wall switch was ruining my late‑night coding sessions.

What You’ll Need

Before you dive in, gather these basics. Nothing fancy, just the stuff most hobbyists already have on their shelves.

Microcontroller – I used an ESP‑32 because it has Wi‑Fi built in and enough pins for a few LEDs and a MOSFET driver.
Power supply – A 5 V USB‑C charger works fine for a single lamp. If you plan to power multiple lights, consider a 12 V brick and a buck regulator.
MOSFETs – One per channel; the IRLZ44N is cheap and handles the current a typical LED strip draws.
Passive components – Resistors, capacitors, a couple of pull‑up resistors for the ESP‑32 pins.
Connectors – A 2‑pin JST for power, a 3‑pin header for the MOSFET gate signals.
PCB design software – KiCad is free and powerful. I’ll reference its UI, but the steps translate to Eagle or EasyEDA as well.
Soldering tools – A fine tip iron, solder, and some flux. If you have a hot‑air rework station, great, but not required.

Sketching the Schematic

1. Start with the block diagram

Draw a quick box diagram on a scrap of paper: ESP‑32 → MOSFET driver → LED load. This helps you see the signal flow and where each component belongs.

2. Add the microcontroller pins

In KiCad’s schematic editor, place the ESP‑32 module. I used the “ESP32‑DevKitC” footprint because it already includes the USB‑C connector for power and programming.

Connect 3.3 V and GND to the power rails.
Choose three GPIO pins (e.g., 18, 19, 21) for the three light channels.

3. Insert the MOSFETs

Place an N‑channel MOSFET for each channel. Connect the drain to the negative side of the LED strip, the source to ground, and the gate to the chosen GPIO pin through a 220 Ω resistor. The resistor protects the ESP‑32 from any sudden spikes.

4. Add decoupling caps

A 0.1 µF capacitor close to each power pin of the ESP‑32 keeps the supply stable. If you’re using a 12 V brick, add a larger electrolytic (10 µF) near the regulator.

5. Label everything

Give each net a clear name: VCC_5V, GND, LED1_GATE, etc. Clear labels save you headaches later when you route the board.

Choosing the Right Footprint

A footprint is the physical shape of a part on the board. Here’s how I kept it simple:

ESP‑32 – Use the “ESP32‑DevKitC‑32D” footprint; it matches the standard breakout board.
MOSFET – The TO‑220 footprint is large but easy to solder by hand. If you prefer a smaller board, go with the “DPAK” version.
Connectors – JST‑PH 2‑pin and 3‑pin footprints are tiny and reliable.
Resistors & Capacitors – 0805 size works for most passive parts and fits on a compact board.

Double‑check the datasheets for pad dimensions. KiCad’s library usually has the correct values, but a quick glance never hurts.

Laying Out the Board

1. Define the board shape

I started with a 4 × 3 inch rectangle – just big enough to sit under my lamp’s base. In the PCB editor, draw the outline and set a 0.2 mm clearance from the edge.

2. Place the components

Put the ESP‑32 near the edge where the USB‑C port will be accessible.
Cluster the MOSFETs together on one side; this keeps the high‑current traces short.
Position the connectors at opposite ends so the power cable and LED leads don’t cross.

3. Route the power traces

Use a 1 mm width for the 5 V rail and the ground plane. For the MOSFET drains, a 0.5 mm trace is enough for a single LED strip, but if you plan to drive a 5 A load, bump it up to 1 mm.

4. Route the signal traces

Keep the GPIO lines thin (0.2 mm) and away from the high‑current paths. A small clearance of 0.2 mm between signal and power keeps noise low.

5. Add a ground pour

Fill the unused copper area with a solid ground pour. This acts as a heat sink for the MOSFETs and improves signal integrity.

Running a Design Rule Check (DRC)

Before you export anything, run KiCad’s DRC. It will flag any clearance violations, unconnected pins, or missing footprints. I caught a missing ground via on the ESP‑32’s EN pin that would have caused a random reset.

Fix all warnings, then run the Electrical Rule Check (ERC) on the schematic. It catches things like a missing pull‑up resistor on an input pin.

Generating Gerbers

Gerber files are the language PCB factories speak. In KiCad:

Click File → Plot.
Choose the layers you need: F.Cu, B.Cu, F.SilkS, B.SilkS, Edge.Cuts, and F.Mask.
Set the drill file option to generate the hole data.
Click Plot and then Generate Drill Files.

Save everything in a zip folder; most fab houses accept this format directly.

Ordering and Assembling

1. Pick a fab house

I like JLCPCB for its low cost and quick turnaround. Upload the zip, select a 1.6 mm board thickness, and choose a 2‑layer stack. For a prototype, the standard 1 oz copper and a matte finish work fine.

2. Review the preview

The fab’s online viewer shows you the board from both sides. Look for any accidental copper islands or missing silkscreen text.

3. Solder the parts

When the boards arrive, start with the smallest components: resistors, capacitors, then the MOSFETs, and finally the ESP‑32. Use a fine‑tip iron and a dab of flux to keep solder joints clean.

4. Flash the firmware

Connect the ESP‑32 via USB‑C, open the Arduino IDE, and upload a simple sketch that toggles the GPIO pins. Test each channel with a multimeter before plugging in the LED strip.

A Quick Test Run

I powered the board with a 5 V charger, opened the serial monitor, and typed 1 to turn the first LED on, 0 to turn it off. The response was instant, and the lamp dimmed smoothly. If you see any flicker, double‑check the MOSFET gate resistor value and make sure the ground plane is solid.

Wrap‑Up Thoughts

Designing a custom PCB for a smart‑light controller may sound like a big project, but breaking it into these bite‑size steps makes it manageable. The biggest payoff is a tidy board that fits exactly where you need it, without the bulk of a generic module. Plus, you get the satisfaction of seeing your own design light up a room.

Happy hacking, and may your next project shine as bright as your ideas!