BZX55C5V1: Measure Where a Zener Shunt Runs Out of Current

A 5.1 V Zener diode can hold a node near its rated voltage while it has current to spare. This circuit lets you see what happens when the input supply falls or an external resistor takes more of the available current. Use two voltage readings and three measured resistance values to estimate how much current remains in the diode. You can do the comparison without inserting an ammeter in the diode branch.

A shunt sits across the load and draws current from the same node. Here the diode is wired in reverse. Its marked cathode goes to the positive output node. Once the reverse voltage is high enough, the diode begins to conduct appreciably. Its voltage changes with current and temperature, especially near the low-current bend in the curve.

Build the 680 Ω feed circuit

  1. Use a Vishay BZX55C5V1-TAP, a 5.1 V nominal Zener in a two-lead axial DO-35 (DO-204AH) glass package. The -TAP order suffix specifies 52 mm tape in an ammopack. Identify the cathode ring from the part marking. Use the exact part for the data-sheet comparisons below.
  2. With output disabled, connect the positive terminal of channel 1 of a SIGLENT SPD3303X bench supply to VIN. Place a 680 Ω ±1%, at least 0.5 W resistor from VIN to VOUT. Connect the diode cathode to VOUT and its anode to G0, the channel 1 negative terminal. Use a small breadboard or insulated terminals. Keep the remaining supply outputs disconnected.
  3. Prepare a 2.2 kΩ ±1%, at least 0.25 W light load and a 470 Ω ±1%, at least 0.5 W heavy load. The chosen resistor goes between VOUT and G0. Leave the load connection open for the first run. Change resistors only while the supply output is off. Measure each resistor out of circuit if you plan to use measured resistance values.
  4. Use two Keysight 34461A digital multimeters in DC voltage mode with the front voltage inputs selected. Use the 100 V range on the VIN meter and the 10 V range on the VOUT meter. Use the nominal 10 MΩ input impedance. Attach both LO leads to G0, the first HI to VIN and the second HI to VOUT. Keep current-measurement terminals unused. Set the channel 1 current limit to 30 mA and confirm it is in constant-voltage mode for every observation.
A 680-ohm resistor feeds the output from a current-limited supply. The BZX55C5V1 cathode and one load meet at the output, and their other ends go to the common return. Separate voltmeters measure both nodes from that return.
Original wiring. The load and the Zener share VOUT and G0. Select one load or leave that branch open. Download the editable SVG.

The highest intended VIN is 10.60 V including the bench acceptance window. Even if VOUT is shorted, the 673.2 Ω lower tolerance bound limits feed current to about 15.75 mA and the feed resistor to about 0.167 W. With a passive load and diode, the diode cannot dissipate more than VIN² / (4 × Rₛ), about 42 mW in this fixture. A conservative bound with VOUT at VIN gives about 0.242 W for the 470 Ω load and 0.052 W for the 2.2 kΩ load. The Vishay 500 mW absolute maximum assumes the specified lead temperature and mounting conditions. Use the fixture bounds for this experiment and leave space around the parts.

Compare source current and load current

Use the actual VIN and VOUT readings for each point. Kirchhoff’s current law says that the feed current splits into the diode, the external load and the output meter. Calculate these currents in amperes before converting to milliamperes.

For a given input and load, this equation is the circuit’s load line. As you raise the proposed VOUT, the feed current falls while load current rises. The operating voltage is where the current the circuit can supply equals the current the diode actually takes at that voltage. Adding a heavier load moves the intersection toward a lower voltage.

Use the 5.1 V nominal value to predict the outcome before taking data. At 9.0 V with the external load open, the feed current would be about 5.74 mA. At the same input with 2.2 kΩ, that load would take 2.32 mA and leave about 3.42 mA for the diode. At 10.5 V with 2.2 kΩ, about 5.62 mA would remain. These examples are conditional on VOUT being 5.1 V. A change in diode voltage changes every inferred current.

With 470 Ω at 9.0 V, the load alone would demand about 10.85 mA at 5.1 V. The feed could supply about 5.74 mA at that same voltage. There is no current budget to sustain 5.1 V. With the diode removed, the two resistors form a divider and the nominal output is about 9.0 × 470 / (680 + 470) = 3.68 V, with a small correction for the output meter. The installed diode can still draw some current at a reduced voltage. The measurements and bounds tell you whether you can resolve it.

Vishay lists 4.8 to 5.4 V at its 5 mA test current for the C5V1 variant. Its small-signal dynamic resistance limits at 1 kHz are below 35 Ω at 5 mA and below 550 Ω at 1 mA. Dynamic resistance describes a small change around a bias current. A difference between widely spaced DC readings does not measure that data-sheet parameter, and the pulsed voltage specification does not set a DC pass band for this board. The diode warms differently during a settled DC reading.

Take nine readings and a divider control

Use each external load at every input setting.
Worksheet railNominal VINExternal loads
low7.50 Vopen, light, heavy
mid9.00 Vopen, light, heavy
high10.50 Vopen, light, heavy
control9.00 Vheavy, diode removed
  1. Set the first condition with power off. Enable the output, check polarity and the actual VIN on the meter. Stop if VIN differs from its intended setting by more than 0.10 V, the supply reports current limiting, a meter overloads or VOUT is below 2.0 V. A short or reversed diode can make a large inferred residual at a very low output. Check that the cathode band goes to VOUT before continuing.
  2. Wait at least 30 seconds. Take another pair of readings five seconds later. If the two VOUT readings differ by more than your intended voltage bound, wait and repeat until the reading stabilizes. Record the stabilized actual VIN and VOUT in volts. Keep the same room and airflow, lead placement and meter settings throughout the comparisons.
  3. At the end, turn off the output and disconnect the diode. Fit the 470 Ω resistor and take the separate 9 V divider control. Recheck the feed and load wiring if the control interval excludes zero diode current. Turn off the output before restoring the diode.

At each input, compare the voltage difference between the open and heavy load. Then compare the change from the lowest to the highest input for each load. If a voltage difference is smaller than the combined voltage bounds, keep it as unresolved. When the residual current interval includes zero, the measurements cannot distinguish weak diode conduction from resistor and meter uncertainty.

Analyze the measured voltages

Download the complete experiment package and copy the blank worksheet to observations.csv. The analyzer starts with nominal resistances, a 1% resistance bound and a ±5 mV bound for each voltage. Those example bounds assume stable readings and a meter setup accurate enough to support them. If you enter measured resistances, set a bound that includes resistance measurement uncertainty and any temperature change. For each node add the meter error and an allowance for drift, then use the larger total of the two. The code treats the output meter as nominally 10 MΩ with a conservative 9–11 MΩ fixture range.

python3 zener_load_line.py observations.csv
python3 zener_load_line.py observations.csv --volts-error 0.008 --resistor-error-percent 1.2
python3 -m unittest -v test_zener_load_line.py

The interval combines extreme input values, so it is a worst-case screen under your supplied bounds. An entirely negative diode residual means the readings and component bounds are inconsistent with the expected current paths. Check the control, both meter ranges, actual load resistance and ground connections. The 1 mA and 5 mA classifications refer to the bias currents used in the data sheet. They help interpret the experiment without turning the diode into an ideal voltage source.

Complete Python analyzer
#!/usr/bin/env python3
"""Analyze measured nodes in the BZX55C5V1 DC shunt fixture."""

import argparse
import csv
import json
import math
import sys


RAILS = {"low": 7.5, "mid": 9.0, "high": 10.5}
LOADS = ("open", "light", "heavy")
COLUMNS = ("rail", "load", "vin_v", "vout_v")


def number(raw, lower, upper, label):
    try:
        value = float(raw)
    except (TypeError, ValueError):
        raise ValueError(f"{label} is missing or is not a number") from None
    if not math.isfinite(value) or not lower <= value <= upper:
        raise ValueError(f"{label} must be from {lower:g} to {upper:g}")
    return value


def quotient(v_low, v_high, r_low, r_high):
    corners = (v_low / r_low, v_low / r_high, v_high / r_low, v_high / r_high)
    return min(corners), max(corners)


def current_class(low, high):
    if high < 0:
        return "negative residual: check circuit and measurement bounds"
    if low <= 0:
        return "positive diode current unresolved"
    if high < 0.001:
        return "positive and below 1 mA"
    if low >= 0.005:
        return "at or above the 5 mA test current"
    if high >= 0.005:
        return "interval includes the 5 mA test current"
    return "positive and below 5 mA"


def analyze(stream, series=680.0, light=2200.0, heavy=470.0,
            resistor_error_percent=1.0, volts_error=0.005):
    series = number(series, 673.2, 686.8, "series resistor in ohms")
    light = number(light, 2178, 2222, "light load in ohms")
    heavy = number(heavy, 465.3, 474.7, "heavy load in ohms")
    fraction = number(resistor_error_percent, 0.05, 2, "resistor bound percent") / 100
    volts_error = number(volts_error, 0.0001, 0.050, "node voltage bound in volts")
    # Conservative engineering envelope for the output meter's 10 MΩ setting.
    meter_low, meter_high = 9e6, 11e6
    load_resistors = {"open": None, "light": light, "heavy": heavy}
    reader = csv.DictReader(stream)
    if tuple(reader.fieldnames or ()) != COLUMNS:
        raise ValueError("unexpected worksheet columns")

    results = {}
    for row in reader:
        rail, load = row["rail"], row["load"]
        key = (rail, load)
        control = key == ("control", "heavy")
        if (not control and (rail not in RAILS or load not in LOADS)
                or key in results or None in row):
            raise ValueError(f"unknown, repeated or malformed condition: {key}")
        nominal = 9.0 if control else RAILS[rail]
        vin = number(row["vin_v"], nominal - 0.10, nominal + 0.10, f"{key} Vin")
        vout = number(row["vout_v"], 2.0, 10.65, f"{key} Vout")
        if vout - vin > 2 * volts_error:
            raise ValueError(f"{key} output exceeds the input beyond the voltage bounds")
        out_low, out_high = vout - volts_error, vout + volts_error
        feed_low, feed_high = quotient(
            vin - volts_error - out_high, vin + volts_error - out_low,
            series * (1 - fraction), series * (1 + fraction),
        )
        load_ohms = load_resistors[load]
        meter_current = vout / 1e7
        sink_low, sink_high = out_low / meter_high, out_high / meter_low
        load_current = 0.0
        if load_ohms is not None:
            load_current = vout / load_ohms
            sink_low += out_low / (load_ohms * (1 + fraction))
            sink_high += out_high / (load_ohms * (1 - fraction))
        low, high = feed_low - sink_high, feed_high - sink_low
        feed = (vin - vout) / series
        results[key] = {
            "rail": rail, "load": load, "vin_v": vin, "vout_v": vout,
            "feed_ma": 1000 * feed, "load_ma": 1000 * load_current,
            "meter_ma": 1000 * meter_current,
            "diode_residual_ma": 1000 * (feed - load_current - meter_current),
            "diode_residual_bound_ma": [1000 * low, 1000 * high],
            "observation": current_class(low, high),
        }

    expected = [(rail, load) for rail in RAILS for load in LOADS]
    if set(results) != set(expected + [("control", "heavy")]):
        raise ValueError("enter the nine conditions and the diode-out control once")
    control_result = results["control", "heavy"]
    control_low, control_high = control_result["diode_residual_bound_ma"]
    heavy_parallel = 1 / (1 / heavy + 1 / 1e7)
    control_result["divider_vout_at_nominal_resistances_v"] = (
        control_result["vin_v"] * heavy_parallel / (series + heavy_parallel)
    )
    control_result["residual_includes_zero"] = control_low <= 0 <= control_high
    return {
        "rows": [results[key] for key in expected],
        "diode_out_control": control_result,
        "vout_high_minus_low_v": {
            load: results["high", load]["vout_v"] - results["low", load]["vout_v"]
            for load in LOADS
        },
        "vout_open_minus_heavy_v": {
            rail: results[rail, "open"]["vout_v"] - results[rail, "heavy"]["vout_v"]
            for rail in RAILS
        },
        "voltage_difference_error_bound_v": 2 * volts_error,
    }


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("csv")
    parser.add_argument("--series-ohm", type=float, default=680.0)
    parser.add_argument("--light-ohm", type=float, default=2200.0)
    parser.add_argument("--heavy-ohm", type=float, default=470.0)
    parser.add_argument("--resistor-error-percent", type=float, default=1.0)
    parser.add_argument("--volts-error", type=float, default=0.005)
    args = parser.parse_args()
    try:
        with open(args.csv, encoding="utf-8-sig", newline="") as stream:
            report = analyze(stream, args.series_ohm, args.light_ohm, args.heavy_ohm,
                             args.resistor_error_percent, args.volts_error)
    except (OSError, ValueError) as error:
        print(f"Input error: {error}", file=sys.stderr)
        return 2
    print(json.dumps(report, indent=2, allow_nan=False))
    return 0


if __name__ == "__main__":
    sys.exit(main())

Try one prediction before you switch the load

Can a 9 V input support 5.1 V across a 1 kΩ load in this fixture?

At 5.1 V the feed would supply about 5.74 mA, while the 1 kΩ load would draw 5.10 mA. About 0.64 mA would remain before accounting for the meter. The current budget suggests a low-current operating point. Use the real diode curve and the measured output to determine its actual voltage.

See the interactive Zener lesson for the ideal clamp first, then compare your measured load dependence with that model. For a separate example of a diode voltage changing with junction temperature, see the 1N4148 forward-voltage experiment. The calculations and Python tests here use illustrative inputs. The blank worksheet is for your own bench readings.

Manufacturer references