A breadboard is fine when I’m proving that an idea works. It’s much less convincing when it’s supposed to sit beside a camera, a monitor or a microphone. My OBS tally light worked on a breadboard, but I wanted several of them around the workshop so I could see when a source was live, a monitor was on screen, or my microphone was muted. That meant making something smaller, tidier and less likely to fall apart when I moved it.
The code had already been finished with AI and tested in the previous project, which you can read about in the previous OBS tally light video. This time, the problem was turning that working breadboard circuit into a proper board.
The first PCB attempt exposed a problem before I ordered anything
I designed the circuit in KiCad using surface-mount components. At a high level, the process is straightforward: draw the schematic, assign the physical footprints, lay out the board, route the traces and create the Gerber files for manufacturing. The difficult bit is making sure the virtual parts match the real ones I intend to solder.
One check I find particularly useful is printing the board layout on paper and placing the actual components on top. That gives me a chance to check the pad positions and pin alignment before a manufacturer turns the design into a batch of boards. It isn’t glamorous, but finding a footprint error on paper is considerably better than finding it after the boards arrive.
My first attempt ran into trouble because I reused an older project containing the power circuitry for the ESP32. After migrating to another computer, I’d lost a custom library. That meant the component wasn’t available as expected while I was live streaming the design process. I ended up deleting it and replacing it with a newer component from KiCad’s built-in library.
That wasn’t necessarily a bad outcome. The replacement used a later library version rather than a custom part I’d assembled to make the old project work. I did adjust the keepout zones slightly so I could arrange the components for this prototype, even though that meant bending the component’s normal layout rules. For a one-off board, I was prepared to accept that compromise.
Once the parts were in sensible positions, I arranged the power input, switch, ESP32 and LEDs, then routed the connections between them. I generated the Gerber files using the settings required for the board manufacturer and uploaded the resulting zip file to JLCPCB. The red boards looked the part when they arrived, and I’ve decided that red will mean prototype boards for now, with a different colour reserved for anything that eventually becomes a production design.
Forgetting the stencil meant making one
There was one fairly important thing I hadn’t ordered: an SMT stencil. Applying solder paste to tiny surface-mount pads without one is possible, but it isn’t a sensible way to get consistent results across a board. The components are small, and too much paste can bridge adjacent contacts.
My first idea was to cut a stencil from PETG with my CO2 laser. That didn’t work particularly well. The laser burned through the plastic, but the edges weren’t clean enough. I found that cardboard produced much cleaner cuts, so I laminated postage labels to the plastic to reinforce it and stop the PETG from melting away from the openings. The result was a home-made stencil that looked good enough to test.
For a jig, I fixed some spare PCBs to a piece of hardboard. They gave me a simple surround to hold the new board in position while I placed the stencil over it and spread the solder paste. The pasting went better than I expected, and I placed the components by hand. The four fiducials on the board would help a production pick-and-place machine such as my LumenPnP locate the board accurately, but for this prototype I was doing the positioning myself.
After that, the board went into my reflow oven. The controller was configured for the solder paste I was using, allowing the paste to heat, melt, flow and solidify through the required temperature profile. This is the stage where excess paste can create bridges and uneven parts can tombstone, standing vertically instead of lying flat. I let the board cool before handling it.
Programming the board and finding out whether it worked
I didn’t yet have a pogo-pin programming jig, so I soldered wires to the programming pins. I used an ESP32 development kit and pulled its enable pin to ground to disable the kit’s onboard microcontroller. With the serial connections arranged correctly, the new board could be programmed through the development kit as though it were communicating with its own controller.
There was always a chance that nothing would happen, the power simply wasn’t connected, or I’d create a short and release the magic smoke. Fortunately, the board powered on, completed its self-test, connected to OBS and responded to the scene triggers. The prototype worked.
That doesn’t make it production-ready. It still needs an enclosure, and I’d like to add buttons so I can switch functions without relying entirely on the web interface. I also want a proper programming jig for future boards. For now, though, I have a compact OBS tally light that works away from the breadboard, and a much better understanding of the mistakes I need to avoid on the next revision.