A two-winding choke can show several millihenries on an LCR meter in one series connection and only tens of microhenries after one winding is reversed. The current passes through the same copper both times. The winding direction determines whether the magnetic effects add or oppose. Four inductance measurements on the Coilcraft CMT1-1.0-6L let you estimate that coupling and check whether the readings fit one simple model.

Identify the exact choke and meter settings

Use a loose Coilcraft CMT1-1.0-6L, a four-pin through-hole choke with tin-silver termination, a Keysight U1733C handheld LCR meter, short test leads and a short removable jumper. The CMT data sheet’s page 3 drawing (Document 326-3, revised 11/04/26) marks pins 1 and 2 with dots. Winding 1 runs from 1 to 4 and winding 2 runs from 2 to 3. Match the data-sheet package drawing to the physical part before clipping leads, especially when working from the underside of a board. A continuity check can identify the two winding pairs. The drawing identifies the dots.

The choke must be loose or removed from its circuit. The meter supplies the only stimulus. Use 10 kHz, series inductance (Ls) with no external DC bias. Disconnect every external supply and leave mains wiring out of the setup. The manufacturer’s electrical table at 25 °C gives 1.0 mH minimum per winding at 15.75 kHz, 0.1 V RMS and 0 A DC, and 0.022 Ω maximum DCR per winding. Keysight specifies the U1733C’s 10 kHz source level as 0.70 V RMS ±0.05 V. The actual voltage across the part depends on the load and meter source impedance. Use the same meter settings throughout and compare the four readings within this fixture.

Four Coilcraft choke connections. The dots are pins 1 and 2. The separate windings are 1 to 4 and 2 to 3. Series aiding bridges 4 to 2 and measures 1 to 3. Series opposing bridges 4 to 3 and measures 1 to 2.
Use one connection at a time. HI and LO are the LCR meter leads. Orange marks the removable series jumper.

Download the editable SVG wiring diagram or download the experiment files and tests.

Collect four sets of readings

  1. Disable the meter’s Ai automatic component identification. Select L, series mode and 10 kHz. Display Q or D on the secondary readout and note which one you chose.
  2. Perform the meter’s open and short corrections at 10 kHz for each fixed range and lead setup you use. Follow the Keysight guide’s shorted-lead Null procedure for the low-inductance ranges to subtract the lead inductance. Check the correction whenever the range or lead setup changes. The data sheet’s low-range accuracy conditions include Q greater than 0.1 (D below 10). Record the active range, resolution and Q or D for each measurement. Stop if the reading overloads, wanders, falls near the residual lead reading, or falls outside the conditions used to set your reading allowance.
  3. Measure the four connections in the table. Use the same short jumper in both series connections and keep the instrument leads close together and in similar positions. Leave both unused pins open during a single-winding reading. Record stable readings in microhenries. A display value of 1.010 mH goes into the sheet as 1010.
  4. Remove and reconnect the leads and jumper between trials. Run the whole table three times, with a complete reconnection for each reading, then enter the results in the 12-row worksheet. Keep the meter conditions in your bench notes. The CSV stores only connection, trial and inductance.
Meter connections, one at a time
ReadingHILOOther pins
Winding 1142 and 3 open
Winding 2231 and 4 open
Series aiding13Jumper 4 to 2
Series opposing12Jumper 4 to 3

Use the difference and check the sum

In the aiding connection, the meter current enters a dotted end of each winding. In the opposing connection, it enters the dotted end of winding 1 and the undotted end of winding 2. In the linear coupled-inductor model the cross terms have the same sign in both voltage contributions for a given connection. Let L1 and L2 be the separate windings’ open-secondary inductances. Let M be the positive mutual inductance with both current references directed into the dots. The two predictions are:

L+ = L1 + L2 + 2M
L− = L1 + L2 − 2M

Subtract the series readings to isolate the mutual term. The winding inductances normalize the result to the dimensionless coefficient k. Adding the same two readings cancels the mutual terms and provides a separate check against the single-winding measurements.

M = (L+ − L−) / 4
k = M / √(L1L2)
(L+ + L−) / 2 = L1 + L2

For an arithmetic example, use the synthetic medians 1000, 1010, 4000 and 20 µH. The two sides of the sum check each give 2010 µH, the mutual inductance is 995 µH, and k is about 0.990. The example numbers are constructed and the worksheet is blank. The software was checked with synthetic inputs. This article has no physical bench measurements. A real choke may give different readings because of loss, winding capacitance, meter excitation, and lead or jumper impedance.

Coilcraft lists 19 µH maximum leakage inductance from pins 1 and 4 with pins 2 and 3 shorted. That connection measures winding 1 with winding 2 acting as a shorted secondary. The series-opposing connection drives both windings from the meter. In the ideal lossless model the shorted-secondary input is L1 − M²/L2; series opposition is L1 + L2 − 2M. Even when close, the readings correspond to different wiring and formulas. Use the data-sheet fixture and stated conditions for a manufacturer-limit comparison.

Challenge

Suppose the two windings both read 1000 µH and the opposing connection reads 20 µH. In the ideal model, what is the mutual inductance, and what would winding 1 show if winding 2 were shorted instead?

Show the calculation

From series opposition, M = (1000 + 1000 − 20) / 2 = 990 µH. With the secondary shorted the model gives 1000 − 990² / 1000 = 19.9 µH. The two readings differ even for matched windings. Use the correct connection to interpret either one.

Run the worksheet analyzer

Save winding_coupling.py beside your CSV. Python 3 and its standard library are sufficient. Run python3 winding_coupling.py observations-filled.csv with your completed file. Run python3 winding_coupling.py synthetic-readings.csv against the included invented example to check the software workflow.

The script expands the smallest and largest reading in each group by the same fractional and fixed allowances. The defaults are 2% of the reading plus 2 µH, chosen for this worksheet. Choose bounds from your range, display resolution, lead correction and observed residuals; change them with --screen-percent (0.1–10) and --floor-uh (0.1–20). If a credible allowance exceeds that range, improve the setup before interpreting this worksheet. The intervals are arithmetic screens over the four input groups. They do not include every model error or express a statistical confidence level.

The repeat check allows a span up to 3% of the group median or twice the absolute floor, whichever is larger. All four lower bounds must remain positive. The aiding interval must be above the opposing interval and the two sum intervals must overlap. A resolved result reports both the median-based estimate and the full interval from the input bounds. An interval crossing 1 stays visible. An interval wholly above 1 fails the physical model check. Exit 0 means the estimate is available, exit 3 means a measurement or model check is unresolved, and exit 2 flags invalid input.

If the sum check fails, first remove all jumpers and verify the winding pairs and dots, then repeat the low-range correction. Compare the opposing measurement to the lead residual and inspect the jumper path before interpreting a difference of only a few microhenries. Keep the full result, including a failed check, with your setup notes. The experiment estimates effective coupling at the meter settings. Common-mode insertion loss, saturation under DC bias and insulation withstand require their own test circuits.

"""Analyze measured series inductances of the Coilcraft CMT bench fixture."""

import argparse
import csv
import json
import math
from pathlib import Path
from statistics import median
import sys

HEADER = ("connection", "trial", "inductance_uh")
CONNECTIONS = ("winding_1_4", "winding_2_3", "series_aiding", "series_opposing")
EPS = 1e-9


def bounded(raw, low, high, name):
    try:
        value = float(raw)
    except (TypeError, ValueError):
        raise ValueError(f"{name}: enter a number") from None
    if not math.isfinite(value) or not low <= value <= high:
        raise ValueError(f"{name}: expected {low:g} through {high:g}")
    return value


def read_worksheet(path):
    if path.stat().st_size > 8192:
        raise ValueError("worksheet exceeds 8 KiB")
    with path.open(encoding="utf-8-sig", newline="") as stream:
        rows = csv.reader(stream, strict=True)
        if tuple(next(rows, ())) != HEADER:
            raise ValueError("use the exact worksheet headings")
        groups = {}
        for connection in CONNECTIONS:
            readings = []
            for trial in ("1", "2", "3"):
                row = next(rows, ())
                if len(row) != 3 or tuple(row[:2]) != (connection, trial):
                    raise ValueError(f"row {rows.line_num}: expected {connection} trial {trial}")
                readings.append(bounded(row[2], 0.1, 20_000.0, f"{connection} trial {trial} µH"))
            groups[connection] = readings
        if next(rows, None) is not None:
            raise ValueError("unexpected extra worksheet row")
    return groups


def summarize(values, percent, floor_uh):
    low = min(values)
    high = max(values)
    representative = median(values)
    return {
        "readings_uh": values,
        "median_uh": representative,
        "interval_uh": [low * (1 - percent) - floor_uh, high * (1 + percent) + floor_uh],
        "repeat_span_uh": high - low,
        "repeatable_within_screen": high - low <= max(0.03 * representative, 2 * floor_uh) + EPS,
    }


def analyze(groups, screen_percent=2.0, floor_uh=2.0):
    percent = bounded(screen_percent, 0.1, 10, "screen percent") / 100
    floor = bounded(floor_uh, 0.1, 20, "absolute floor in µH")
    measured = {key: summarize(values, percent, floor) for key, values in groups.items()}
    first, second, plus, minus = (measured[name] for name in CONNECTIONS)
    intervals = [item["interval_uh"] for item in (first, second, plus, minus)]
    ((a0, a1), (b0, b1), (p0, p1), (m0, m1)) = intervals
    winding_sum = [a0 + b0, a1 + b1]
    series_mean = [(p0 + m0) / 2, (p1 + m1) / 2]
    checks = {
        "all_connection_repeats_pass": all(item["repeatable_within_screen"] for item in measured.values()),
        "all_lower_inductance_bounds_positive": min(low for low, _ in intervals) > EPS,
        "aiding_resolved_above_opposing": p0 > m1 + EPS,
        "series_mean_agrees_with_winding_sum": max(winding_sum[0], series_mean[0]) <=
                                               min(winding_sum[1], series_mean[1]) + EPS,
    }
    output = {
        "scope": "Effective series inductance and coupling model at the stated meter settings.",
        "screen_percent_each_reading": screen_percent, "screen_floor_uh_each_reading": floor_uh,
        "measurements": measured, "winding_sum_interval_uh": winding_sum,
        "series_mean_interval_uh": series_mean, "checks": checks,
        "mutual_uh": None, "coupling": None,
    }
    if not all(checks.values()):
        return dict(output, status="measurement_checks_unresolved")

    mutual = (plus["median_uh"] - minus["median_uh"]) / 4
    mutual_low, mutual_high = (p0 - m1) / 4, (p1 - m0) / 4
    nominal_k = mutual / math.sqrt(first["median_uh"] * second["median_uh"])
    k_low = mutual_low / math.sqrt(a1 * b1)
    k_high = mutual_high / math.sqrt(a0 * b0)
    if k_low > 1 + EPS:
        return dict(output, status="coupling_interval_entirely_above_one")
    # Keep the full input-screen interval, including any portion above one.
    # This makes the size of uncertainty and model mismatch visible.
    return dict(output, status="effective_coupling_estimated",
                mutual_uh={"median_input_estimate": mutual, "screen_interval": [mutual_low, mutual_high]},
                coupling={"median_input_estimate": nominal_k, "screen_interval": [k_low, k_high],
                          "screen_interval_crosses_one": k_low <= 1 + EPS and k_high > 1 + EPS})


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("worksheet", type=Path)
    parser.add_argument("--screen-percent", type=float, default=2.0)
    parser.add_argument("--floor-uh", type=float, default=2.0)
    args = parser.parse_args()
    try:
        result = analyze(read_worksheet(args.worksheet), args.screen_percent, args.floor_uh)
    except (OSError, ValueError, csv.Error) as error:
        print(f"worksheet rejected: {error}", file=sys.stderr)
        return 2
    print(json.dumps(result, indent=2, allow_nan=False))
    return 0 if result["status"] == "effective_coupling_estimated" else 3


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

Manufacturer references and related experiment