Overview
Hold-up time testing checks whether a power supply maintains its outputs after AC input is removed. It needs capacitive loads switched in and out during the test. Nothing commercial does this: electronic loads handle resistive and constant-current profiles, but capacitor banks need relay switching with different safety constraints.
I built this to fill that gap in the TDK-Lambda ATE system. It sat on the bench alongside commercial instruments from Chroma, Kikusui, and Lecroy, controlled through the same software framework.
The Circuit
An ATmega microcontroller driving Schrack relays. Relays rather than solid-state switches because capacitive inrush currents are substantial, and galvanic isolation keeps the high-power load path completely separate from the control circuitry. USB serial communication with a simple command protocol: open channel, close channel, query state.
The firmware is intentionally minimal. All the intelligence lives in the VB.NET test software, which treats this through the same driver abstraction layer as every other instrument on the bench.
Prototype to Production
The first version was an Arduino Nano on stripboard, hand-wired to relays, powered from USB. Good enough to validate the concept and run initial tests, but fragile: hand-soldered connections, too large for permanent bench installation, and not reliable enough for overnight unattended runs.
I designed a custom PCB with the same ATmega chip and the same firmware (zero code changes), in a compact form factor with proper connectors. The PCB version became a permanent fixture on the test bench.
ATE Integration
The ATE system's driver abstraction layer means every instrument implements the same interface pattern. I wrote a VB.NET driver following the identical pattern as the Chroma, Kikusui, and Lecroy drivers. Test code couldn't tell the difference between commanding this custom PCB and a commercial instrument.
This is the same framework described in the TDK-Lambda ATE system project. The capacitive load switch was the only custom instrument in the rack, but it integrated seamlessly because the abstraction was designed from the start to support exactly this kind of extension.
Architecture
ATmega microcontroller driving Schrack relays over GPIO, with USB serial communication via FTDI. The firmware handles relay control and state reporting through a simple command protocol. On the host side, a VB.NET instrument driver wraps the serial communication behind the same interface used for commercial VISA instruments, so the ATE framework treats it identically.
Key Features
Purpose-built to fill a gap where no commercial instrument existed for capacitive load switching
Schrack relay array with galvanic isolation between control circuitry and high-current load paths
Same driver abstraction interface as commercial instruments from Chroma, Kikusui, and Lecroy
Arduino prototype to production PCB with zero firmware changes, running unattended in overnight test sequences
What I Learned
Building a custom instrument taught me that the build/buy decision isn't always about cost. Sometimes nothing on the market does exactly what you need, and a purpose-built tool that does one thing well beats trying to repurpose something general.
Designing the driver to the same interface as commercial instruments was the best decision on the project. It meant zero changes to test procedures and zero special-casing in the framework.
Going from prototype to PCB reinforced that the jump from 'it works on the bench' to 'it works unattended overnight' is mostly about reliability, not functionality. The circuit was identical; the difference was proper connections and a form factor that could be permanently installed.
