Transistor Module Dead Time Setting: Techniques That Prevent Shoot-Through and Save Your Hardware

Dead time is the parameter that separates a reliable power converter from a smoking pile of silicon. Set it too short and both switches in a bridge leg conduct at the same time — the bus voltage shorts through the devices, current spikes to hundreds of amps in microseconds, and the modules are gone before your protection circuit can blink. Set it too long and the body diodes conduct for too long, reverse recovery current hammers the switches, and your efficiency drops by several percentage points.

Finding the right dead time is not a calculation you do once and forget. It is an iterative process that changes with temperature, load, and aging. This guide covers the actual techniques experienced power engineers use to nail dead time every time.

What Dead Time Actually Means in Practice

Dead time is the gap between turning off one switch and turning on the other in the same bridge leg. During this gap, neither switch conducts. The load current freewheels through the body diode of the device that just turned off. The length of this gap must be long enough to guarantee the first switch is fully off before the second one starts turning on.

But "fully off" is not a single number. An IGBT does not snap from on to off instantly. After the gate signal goes low, there is a turn-off delay, then a current fall time, then a tail current period where the device is still conducting a small amount of current while it recovers its blocking voltage. The total turn-off time can range from 200 nanoseconds for fast MOSFETs to over 2 microseconds for large IGBTs at high temperature.

Your dead time must cover the entire turn-off sequence plus a safety margin. That margin is where most engineers get it wrong.

The Temperature Problem Nobody Talks About

Why Your Room-Temperature Dead Time Fails at 125°C

Here is the dirty secret: dead time is not a fixed number. It is a function of junction temperature, and the relationship is brutal. As temperature climbs, carrier mobility drops, the tail current extends, and the device takes longer to fully block voltage. An IGBT that turns off in 800 nanoseconds at 25°C might take 1.5 microseconds at 125°C.

If you sized your dead time for room temperature, you have zero margin at operating temperature. The moment the module heats up under load, your dead time shrinks relative to the actual turn-off time, and shoot-through becomes a matter of when, not if.

The fix is straightforward but often ignored: measure turn-off time at maximum expected junction temperature, then add at least 500 nanoseconds of safety margin on top of that. For IGBT modules running in motor drives or inverters where junction temperature routinely hits 125°C, this means your dead time should be in the range of 2 to 4 microseconds — not the 1 microsecond you probably calculated from the room-temperature datasheet.

How to Measure Actual Turn-Off Time Under Load

Do not trust the datasheet turn-off time for dead time sizing. Datasheet values are measured under specific test conditions that rarely match your real circuit. Your actual turn-off time depends on gate drive strength, bus voltage, load current, and PCB parasitic inductance.

Grab a four-channel oscilloscope. Probe the gate voltage of the switching device and the collector-emitter voltage (for IGBTs) or drain-source voltage (for MOSFETs). Trigger on the falling edge of the gate signal. Measure the time from when the gate crosses the threshold voltage to when the collector-emitter voltage reaches 90% of the bus voltage. That is your real turn-off time.

Do this at three points: cold startup (25°C), steady-state operating temperature, and maximum load. Use the longest value you measure. That is the number you build your dead time around.

Fixed vs Adaptive Dead Time: When Each One Wins

Fixed Dead Time Works Until It Does Not

Fixed dead time is the simplest approach. You pick a number in the controller or driver and that is what you get, every cycle, regardless of conditions. It works fine for constant-frequency applications like motor drives running at a fixed switching frequency.

The problem shows up when your switching frequency changes. At high frequency, the switching period shrinks, and a fixed dead time of 2 microseconds might eat up 10% or more of your cycle — killing your effective duty cycle range and reducing output voltage capability. At low frequency, that same 2 microseconds is negligible, but it might still be longer than necessary, wasting efficiency.

Fixed dead time also does not account for part-to-part variation. Two modules from the same production batch can have turn-off times that differ by 20%. If you size dead time for the slowest device, the fast one wastes energy every cycle. If you size it for the fastest, the slow one gets no margin.

Adaptive Dead Time Self-Adjusts to Reality

Adaptive dead time eliminates these problems by measuring the actual turn-off event and only enabling the complementary switch after the first device has fully recovered. The driver monitors the collector-emitter voltage (or drain-source voltage) of the outgoing switch. When that voltage rises above a threshold — typically 10% to 20% of the bus voltage — the driver knows the device has turned off and enables the other switch.

This approach guarantees minimum safe dead time under all conditions. At high temperature, the dead time automatically extends because the turn-off takes longer. At low temperature, it shrinks because the turn-off is faster. The result is maximum efficiency at every operating point without any risk of shoot-through.

The catch: adaptive dead time requires a driver with desaturation detection or active voltage sensing on the switch node. Not every driver supports this. If yours does not, you are stuck with fixed dead time, and you must size it conservatively for the worst case.

Dead Time and Body Diode Reverse Recovery

The Hidden Loss Mechanism

When dead time is too long, the body diode of the outgoing switch conducts the load current during the dead time interval. When the complementary switch turns on, it does not turn on into zero voltage — it turns on into the forward voltage of the body diode, typically 0.7V to 1.5V. This forces the body diode to stop conducting abruptly, and that abrupt stop causes reverse recovery.

During reverse recovery, the body diode briefly conducts in the reverse direction, pulling a large current spike from the bus. This spike flows through the switch that is about to turn on, adding to its turn-on loss and generating voltage ringing across the stray inductance in the commutation loop. The faster the diode recovers, the smaller the spike — but most standard body diodes have reverse recovery times of 50 to 200 nanoseconds, and the recovery current can be several times the forward current.

Shortening dead time reduces the time the body diode conducts, which reduces reverse recovery loss. But you cannot shorten it so much that shoot-through risk rises. The optimal dead time is the shortest value that still guarantees no overlap, and that value changes with load current because reverse recovery charge increases with current.

Using Schottky Diodes to Cheat the Problem

If your application demands very short dead time, consider adding a Schottky diode in parallel with each switch's body diode. Schottky diodes have virtually zero reverse recovery charge. When the complementary switch turns on, the Schottky clamps the voltage and prevents the body diode from entering reverse recovery. This lets you shrink dead time to 100 nanoseconds or less without the reverse recovery penalty.

The trade-off is cost and board space. Schottky diodes rated for the same current as your transistor module are physically large and expensive at high power levels. For modules above 200A, the Schottky approach becomes impractical, and you are back to managing dead time carefully with adaptive control.

Practical Dead Time Tuning Workflow

Start with the datasheet turn-off time at maximum junction temperature. Add 500 nanoseconds to 1 microsecond of margin. Set this as your initial dead time in the controller.

Power up the system at no load. Probe both switch nodes with the oscilloscope. Look for any overlap — even a 50 nanosecond overlap means shoot-through is happening. If you see overlap, increase dead time by 100 nanoseconds and recheck.

Ramp up to full load. Check again. At high current, turn-off times lengthen and reverse recovery worsens. You might need to add another 200 to 500 nanoseconds.

Run the system at maximum temperature. Let it soak for at least 30 minutes until thermal equilibrium. Capture the waveforms one more time. If the dead time margin has shrunk below 200 nanoseconds, increase it.

One final check: vary the switching frequency if your application allows it. At the highest frequency, verify that dead time does not consume more than 5% of the switching period. If it does, consider switching to adaptive dead time to recover that lost duty cycle.

Common Mistakes That Kill Modules

Sizing dead time from typical datasheet values instead of worst-case measured values. This is the number one mistake. Typical values are for 25°C. Your module runs at 125°C.

Ignoring the difference between IGBT and MOSFET turn-off behavior. IGBTs have tail current. MOSFETs do not. Applying IGBT dead time rules to MOSFETs wastes efficiency. Applying MOSFET rules to IGBTs causes shoot-through.

Forgetting that dead time must be set per leg, not globally. In a three-phase inverter, each leg has slightly different parasitic inductance and thermal conditions. One leg might need 2.5 microseconds while another needs 3.0 microseconds. Setting a single global dead time forces you to use the worst case for all legs, wasting efficiency on the faster ones.

Not re-checking dead time after a module replacement. A new module might have a different turn-off time than the old one. Even a 100 nanosecond difference can collapse your margin if you were already running tight.