A frequency-to-voltage converter can report 600 Hz as a steady voltage, but a steady reading takes time. With the Texas Instruments LM2907N-8/NOPB, one capacitor determines how much charge the converter moves and another smooths the resulting pulses. Exchange the smoothing capacitor and measure three effects together: settled scale, ripple and response time.
This fixture uses 200 Hz and 600 Hz square-wave bursts from a generator. A two-channel oscilloscope records the input and the charge-pump node on the same time axis. All values below are design calculations or proposed screening limits. The observation files are blank. This circuit has not been physically tested.
Use the TI LM2907N-8/NOPB with its P plastic dual in-line package (PDIP-8). With the notch up and the pin-1 marker at the top left, pin numbers descend the left side and ascend the right. The 14-pin LM2907 has different pins and input behavior. TI’s separate LM2917 includes a supply zener regulator. Check the full orderable on the bag.

| Pin | Fixture connection and purpose |
|---|---|
| 1 · TACH+ | Tektronix AFG1022 channel 1 through 1.00 kΩ. The ground-referenced input comparator detects both polarities. The scope channel 1 tip measures this pin. |
| 2 · CP1 | C1, 10 nF ±5% film, from pin to G0. Example WIMA MKS2C021001A00JSSD. This timing capacitor accepts and returns charge on alternate input half cycles. |
| 3 · CP2/IN+ | R1, 47.0 kΩ ±1%, and one C2 in parallel to G0. Fit either KEMET R82DC3220DQ60J (220 nF, ±5%) or R82DC4100DQ60J (1.0 µF, ±5%). Scope channel 2 tip here. This is also the internal amplifier’s noninverting input. |
| 4 · EMIT | Emitter output to pin 7 and 10 kΩ to G0. The output stage follows the charge-pump voltage through this feedback loop. |
| 5 · COL | Output transistor collector to +12 V. |
| 6 · V+ | +12 V. Use C3, 100 nF ceramic rated ≥25 V, close to pins 6/8. Add C4, 10 µF nonpolar rated ≥25 V, across the local supply. |
| 7 · IN− | Inverting feedback input connects directly to pin 4. |
| 8 · TACH−/GND | G0, the common return for the chip, generator and both probe clips. |
Use compact wiring with short probe returns. A standalone, isolated SIGLENT SPD3303X channel powers the fixture at 12.00 V with a nominal 50 mA current limit. Connect its negative output to G0. Use no other supply or floating live node. The generator shield and both oscilloscope probe ground clips connect only to G0. Verify the generator when its signal lead is disconnected. With high-impedance output scaling, start with a square wave of 0.80 V peak-to-peak and 0 V offset. Check about +0.40 V and −0.40 V at the actual pin after connecting. A 0-to-positive pulse alone does not meet this experiment’s bipolar input requirement.
Enable the fixture supply before enabling the generator output. Turn the generator output off before the supply; then verify the IC rail and filter node have discharged before changing C2. Stop if the supply remains in current limit, if the chip warms unexpectedly, or if waveform levels are outside the fixture window. Scope ground clips are never a means of creating a separate negative rail.
A charge pump transfers a small packet of charge each half cycle. At fixed input frequency, the average pump current flowing into R1 produces a voltage. TI’s first-order model below includes K, an internal gain factor. The table uses nominal component values and K = 1.
I̅ ≈ VCC × f × C1V̅CP2 ≈ K × VCC × f × C1 × R1τ ≈ R1 × C2t90 ≈ −ln(0.1) × τ
| Design quantity | 220 nF | 1.0 µF |
|---|---|---|
| Mean at 200 Hz | 1.128 V | 1.128 V |
| Mean at 600 Hz | 3.384 V | 3.384 V |
| RC time constant | 10.34 ms | 47.0 ms |
| Continuous first-order 90% time | 23.8 ms | 108.2 ms |
| Approximate 600 Hz CP2 ripple | 164 mV peak-to-peak | 36 mV peak-to-peak |
TI equation 6 estimates peak-to-peak ripple as (VCC/2) × (C1/C2) × [1 − VCCfC1/I2] with pump current I2. Substituting 180 µA typical gives the two estimates at 600 Hz. Twice-per-cycle pumping, finite charge time and the real output impedance make the continuous exponential and ripple equation approximations. The observed 90% time below comes from complete acquired input cycles.
For a planning check, at 600 Hz with 12.10 V and C1 at its +5% value, VCCfC1 ≈ 76.2 µA. Charging half the supply swing at 140 µA would take about 454 µs, shorter than the 833 µs half period. The 140 µA minimum comes from TI’s 12 V, 25 °C electrical-characteristics table with CP1 and CP2 both set to 6 V. It is a design comparison for this room-temperature fixture. The 600 Hz nominal CP2 voltage has substantial margin to the follower’s stated upper common-mode boundary, VCC − 1.5 V. The nominal follower load is about 0.34 mA at 3.384 V. It is connected at pin 4 so the 10 kΩ load does not appear in parallel with R1. A 10 MΩ probe on CP2 alone makes the 47 kΩ effective resistance about 46.78 kΩ, a reduction of 0.47% before internal effects. Keep that same probe attached in all four runs.
TI gives a ±40 mV maximum input-threshold magnitude at its specified 250 mV peak-to-peak, 1 kHz test condition. Use the verified bipolar fixture drive above to provide clear margin. The datasheet’s 28 V supply absolute maximum is a stress rating. This experiment uses measured 11.90–12.10 V and quiet low-voltage input; it never connects to an ignition pickup, motor harness or a vehicle supply.
time_s,tach_v,cp2_v with actual seconds and volts including the probe factor exactly once. Retain all acquired samples for a continuous window with at least the specified prefix and active span. If the raw export has instrument preamble, remove those lines from the analysis copy. Save one CSV beside the blank worksheet per run. If the normalized file would exceed 9 MB, select a suitable lower native scope memory setting that still satisfies the time step and coverage. Do not decimate blindly.fast200, fast600, smooth200 and smooth600. Record the voltage at pin 6 relative to G0 with a handheld meter at each run and enter the actual trace filename. If any setting, probes, grounding or R1 changed, restart the comparison.Fill the blank four-run worksheet and run python3 pump_response.py observations.csv. The program time-weights the waveform by linear interpolation between raw samples. It checks the frequency using elapsed time across many qualified rising edges. Each new edge must follow a sample at or below −0.20 V, then reach +0.20 V. Individual observed periods must be within 5% of the expected period. Inspect the trace for ringing or clipped amplitudes that a finite sampling interval can miss.
The program calculates means for complete cycles from each qualified rise to the next. It uses the median cycle mean wholly inside 400–450 ms as the late voltage and checks prior late drift using 350–400 ms. The 90% line starts at the pre-burst baseline. The reported time is the end of the first complete cycle whose mean reaches that line and remains above it across the subsequent complete cycles through 450 ms. It is quantized by the input period and referenced to the first witnessed full bipolar rise, within roughly one nominal period of a clean burst onset. It does not certify every instantaneous CP2 sample at that level. A noisy or late response is unresolved.
For each run, the program also reports the median sampled peak-to-peak ripple in the 400–450 ms window. It compares the baseline-subtracted late CP2 voltage divided by measured supply and frequency across all runs. Require a spread no larger than 10% of the median normalized value. At 600 Hz, require the 220 nF ripple to exceed the 1.0 µF ripple by more than 16 mV. At each frequency, require the 1.0 µF 90% time to exceed the 220 nF time by more than 15 ms. These are fixture screens selected for a clear demonstration. They are neither instrument uncertainty nor device acceptance limits. With visibly noisy or clipped data or inadequate scope resolution, repeat the setup before interpreting the numerical result.
Exit 0 means all contrasts pass. Exit 3 means supplies, capture or comparison left at least one result unresolved. Exit 2 means the worksheet or waveform file is malformed. Failed screens are named in JSON output. Example failure: repeated cycles disappear even though the generator indicates 600 Hz. Look at the actual negative and positive input levels and verify the return path before changing the output filter.
Download the Python analyzer or get the diagrams, worksheets and synthetic host tests. The Python 3 program uses only the standard library. The synthetic tests evaluate arithmetic and fault handling. This bench circuit has no firmware.
#!/usr/bin/env python3
"""Compare LM2907 conversion, sampled ripple and sustained settling."""
import argparse
from bisect import bisect_left, bisect_right
import csv
import json
import math
from pathlib import Path
from statistics import median
RUNS = ("fast200", "fast600", "smooth200", "smooth600")
TRACE_HEADER = ("time_s", "tach_v", "cp2_v")
SUMMARY_HEADER = ("run", "rail_v", "trace")
EPS = 1e-9
def inside(x, low, high):
return low - EPS <= x <= high + EPS
def finite(value):
number = float(value)
if not math.isfinite(number):
raise ValueError("Nonfinite observation")
return number
def read_table(path, expected, max_bytes):
if path.stat().st_size > max_bytes:
raise ValueError(f"{path.name}: file exceeds the fixture size limit")
with path.open(encoding="utf-8-sig", newline="") as file:
reader = csv.reader(file, strict=True)
if tuple(next(reader, [])) != expected:
raise ValueError(f"{path.name}: expected {','.join(expected)}")
for row in reader:
if len(row) != len(expected):
raise ValueError(f"{path.name}: wrong column count on row {reader.line_num}")
yield row
def parse_summary(path):
entries = {}
for run, rail, name in read_table(path, SUMMARY_HEADER, 8192):
if run not in RUNS or run in entries:
raise ValueError(f"Unexpected or duplicate run {run!r}")
if not name or Path(name).name != name or Path(name).suffix.lower() != ".csv":
raise ValueError("Each trace must be a CSV beside the worksheet")
trace = (path.parent / name).resolve()
if trace.parent != path.parent.resolve() or trace == path.resolve():
raise ValueError("Trace must resolve beside the worksheet")
entries[run] = finite(rail), trace
if set(entries) != set(RUNS) or len({p for _, p in entries.values()}) != len(RUNS):
raise ValueError("Four separately captured traces are required")
return entries
def trace_metrics(path, hz, rail):
rows = [tuple(map(finite, row)) for row in read_table(path, TRACE_HEADER, 9_000_000)]
if len(rows) < 3:
raise ValueError(f"{path.name}: too few samples")
t, tach, cp = zip(*rows)
if any(not -60 <= x <= 60 for x in t) or any(abs(x) > 30 for x in (*tach, *cp)):
raise ValueError(f"{path.name}: unreasonable sample units")
if any(b <= a for a, b in zip(t, t[1:])):
raise ValueError(f"{path.name}: sample times must strictly increase")
if any(b - a > 50e-6 + EPS for a, b in zip(t, t[1:])):
return None, "sample gap above 50 us"
if not inside(rail, 11.90, 12.10):
return None, "12 V rail outside fixture window"
if min(cp) < -.10 - EPS or max(cp) > 5 + EPS:
return None, "CP2 capture exceeds fixture bounds"
if min(tach) < -.65 - EPS or max(tach) > .65 + EPS:
return None, "TACH+ capture exceeds fixture bounds"
rises = []
waiting = False
for index, value in enumerate(tach):
if value <= -.20:
waiting = True
elif waiting and value >= .20:
if index:
a, b = t[index - 1:index + 1]
y0 = tach[index - 1]
rises.append(a + (.20 - y0) * (b - a) / (value - y0))
waiting = False
if not rises:
return None, "no full qualified bipolar TACH+ crossing"
first = rises[0]
if first - t[0] < .025 - EPS or t[-1] - first < .46 - EPS:
return None, "short capture around first qualified bipolar crossing"
pre = cp[bisect_left(t, first - .025):bisect_right(t, first - .005)]
initial = median(pre)
if abs(initial) > .030 + EPS or max(pre) - min(pre) > .030 + EPS:
return None, "pre-burst CP2 baseline not quiet and near zero"
early = [edge for edge in rises if edge - first <= .46 + EPS]
periods = [right - left for left, right in zip(early, early[1:])]
if len(periods) < 80 or early[-1] - first < .45 - EPS:
return None, "burst does not cover the required active window"
if any(not inside(p, .95 / hz, 1.05 / hz) for p in periods):
return None, "missing, extra or out-of-rate crossing"
measured_hz = len(periods) / (early[-1] - first)
area = [0.0]
for i, right in enumerate(t[1:], 1):
area.append(area[-1] + (cp[i - 1] + cp[i]) * (right - t[i - 1]) / 2)
def at_edge(edge):
i = min(bisect_right(t, edge) - 1, len(t) - 2)
fraction = (edge - t[i]) / (t[i + 1] - t[i])
voltage = cp[i] + fraction * (cp[i + 1] - cp[i])
integral = area[i] + (voltage + cp[i]) * (edge - t[i]) / 2
return i, voltage, integral
cycle_rows = []
for start, end in zip(early, early[1:]):
left, y_left, a_left = at_edge(start)
right, y_right, a_right = at_edge(end)
values = (y_left, *cp[left + 1:right + 1], y_right)
cycle_rows.append((start - first, end - first,
(a_right - a_left) / (end - start),
max(values) - min(values)))
early_tail = [r for r in cycle_rows if r[0] >= .35 - EPS and r[1] <= .40 + EPS]
late_tail = [r for r in cycle_rows if r[0] >= .40 - EPS and r[1] <= .45 + EPS]
if not early_tail or not late_tail:
return None, "not enough complete tail cycles"
final = median(r[2] for r in late_tail)
ripple = median(r[3] for r in late_tail)
if abs(median(r[2] for r in early_tail) - final) > .020 + EPS:
return None, "late cycle means not stable"
nominal = rail * measured_hz * 10e-9 * 47000
if not inside(final - initial, nominal * .75, nominal * 1.25):
return None, "late response outside nominal planning screen"
threshold = initial + .9 * (final - initial)
misses = [i for i, row in enumerate(cycle_rows)
if row[1] <= .45 + EPS and row[2] < threshold - EPS]
next_index = misses[-1] + 1 if misses else 0
if next_index >= len(cycle_rows):
return None, "90 percent not sustained in first 300 ms"
first_stay = cycle_rows[next_index]
if first_stay[1] > .30 + EPS:
return None, "90 percent not sustained in first 300 ms"
return {
"rail_v": rail, "input_hz": measured_hz, "initial_v": initial,
"late_cp2_v": final, "median_sampled_ripple_vpp": ripple,
"nominal_r1c1_prediction_v": nominal, "settled_90_cycle_end_s": first_stay[1],
"normalized_conversion_s": (final - initial) / (rail * measured_hz),
}, None
def analyze(entries):
output = {}
for run in RUNS:
rail, path = entries[run]
result, error = trace_metrics(path, int(run[-3:]), rail)
output[run] = {"observed": result, "reason": error}
if any(item["reason"] for item in output.values()):
return {"supported": False, "runs": output, "contrasts": None}
obs = {name: item["observed"] for name, item in output.items()}
slopes = [item["normalized_conversion_s"] for item in obs.values()]
small, large = obs["fast600"], obs["smooth600"]
fast_ripple, slow_ripple = (row["median_sampled_ripple_vpp"] for row in (small, large))
settle_closure = all(
obs[f"smooth{hz}"]["settled_90_cycle_end_s"] >
obs[f"fast{hz}"]["settled_90_cycle_end_s"] + .015 + EPS
for hz in (200, 600)
)
contrasts = {
"normalized_conversion_spread_within_10_percent":
max(slopes) - min(slopes) <= .10 * median(slopes) + EPS,
"600hz_sampled_ripple_reduction_above_16mv": fast_ripple - slow_ripple > .016 + EPS,
"both_90_percent_settling_increases_above_15ms": settle_closure,
}
return {"supported": all(contrasts.values()), "runs": output, "contrasts": contrasts}
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("worksheet", type=Path)
args = parser.parse_args()
try:
result = analyze(parse_summary(args.worksheet))
except (OSError, ValueError, csv.Error) as exc:
parser.exit(2, f"Input error: {exc}\n")
print(json.dumps(result, indent=2, allow_nan=False))
return 0 if result["supported"] else 3
if __name__ == "__main__":
raise SystemExit(main())
Doubling R1 doubles the nominal voltage-per-hertz scale and the first-order time constant, while R1 is absent from TI’s ripple estimate. Doubling C2 halves that estimate and doubles the time constant while leaving nominal scale unchanged. Doubling R1 also reduces voltage headroom at high frequencies. Check operating limits before trying either change.
See why the AFG1022’s displayed voltage depends on its load setting before choosing the input amplitude.