LM2907: Smooth a Frequency Reading Without Changing Its Scale

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.

Connect the 8-pin converter

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.

LM2907N-8/NOPB PDIP schematic. The ground-centered generator drives TACH plus through 1 kiloohm. A 10 nanofarad timing capacitor connects CP1 to ground; 47 kiloohms and one selectable filter capacitor connect CP2 to ground. The emitter returns to the inverting input and drives a 10 kiloohm load. Collector and supply go to the bypassed 12 volt rail. The scope observes pins 1 and 3.
Measure the charge-pump node at pin 3 and keep the emitter follower connected. Change only the filter capacitor C2. Full-size PNG · Editable schematic
PinFixture 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 · CP1C1, 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 · EMITEmitter output to pin 7 and 10 kΩ to G0. The output stage follows the charge-pump voltage through this feedback loop.
5 · COLOutput 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−/GNDG0, 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.

Calculate the scale and compare the time constants

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 × C1
V̅CP2 ≈ K × VCC × f × C1 × R1
τ ≈ R1 × C2
t90 ≈ −ln(0.1) × τ

Design quantity220 nF1.0 µF
Mean at 200 Hz1.128 V1.128 V
Mean at 600 Hz3.384 V3.384 V
RC time constant10.34 ms47.0 ms
Continuous first-order 90% time23.8 ms108.2 ms
Approximate 600 Hz CP2 ripple164 mV peak-to-peak36 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.

Capture four bursts

  1. Set RIGOL DHO804 channels 1 and 2 to direct-current coupling, 1 MΩ and 10× probe scaling. Use two PVP2350 probes set to 10×, compensate them before testing, and keep their positions, vertical settings and bandwidth settings fixed. At the chosen scale, both the full CP2 rise and the smaller ripple must be on screen. For example, start CH2 at 500 mV/div with a vertical position that includes 0 to at least 4.2 V; increase to 1 V/div if necessary and verify you can still resolve ripple. With a quiet input, inspect CH2’s baseline first.
  2. For each fitted C2, use AFG1022 channel 1 triggered N-cycle burst, manual trigger, 200 cycles at 200 Hz and 600 cycles at 600 Hz. That supplies about a second of active waveform. Before the first run inspect the idle voltage and burst start. Ensure the pin is quiet while idle and the active waveform alternates below −0.20 V and above +0.20 V. Adjust start phase or single-trigger position to capture the beginning, while retaining ≥25 ms of pretrigger and ≥460 ms following the first qualified rise. This rise can be one period after the physical onset if the burst begins on the positive plateau. Use the same onset convention for both capacitors. No run begins until CP2 is back near zero.
  3. Use a single normal acquisition at approximately 100 ms/div and 100 kpts with only channels 1 and 2 enabled. Trigger on the positive TACH voltage around +0.20 V, and position the trigger toward the first tenth of the display. Verify actual time coverage and sample intervals on the next step. Keep samples at ≤50 µs and choose stable vertical positions to avoid clipping. To export each stopped acquisition, choose Storage → Save Wave → Memory → CSV. Preserve both channels from the same acquisition. Use the actual saved time and voltages, not the display divisions or scope screenshots.
  4. Keep the raw files. For the script copy the simultaneous acquired columns, in order, into the trace schema. Use 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.
  5. Repeat at both frequencies with the other C2, powering down and verifying discharge before replacement. Use runs 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.

Decide whether the contrast is resolved

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.

Complete analyzer

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())

Challenge

R1 is doubled while C2 stays fixed. Does that smooth ripple the same way as doubling C2?

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.

References

See why the AFG1022’s displayed voltage depends on its load setting before choosing the input amplitude.