Add two clean sine waves and their original frequencies remain. Multiply the same waves and two different frequencies appear. In this bench experiment, an Analog Devices AD633JNZ turns 1.0 kHz and 1.7 kHz inputs into a 700 Hz difference tone and a 2.7 kHz sum tone. Move the second generator to the inverting input and both new tones change sign. Ground both inputs of that pair and the product disappears from the ideal equation. Three scope captures test those predictions.

The AD633 is a four-quadrant multiplier, which means its two input voltages can be positive or negative and the output follows the sign of their product. A sine wave crosses zero twice per cycle. The circuit therefore tests all four combinations during one acquisition. The examples are calculations and the observation file is blank.

Connect a low-voltage split supply and three probes

Top-view AD633JNZ with pin 1 receiving a 1 kHz sine through 100 ohms, pins 2 and 6 grounded, and the 1.7 kHz sine routed to either pin 3 or 4. Ground both for the control. Pin 8 and pin 5 use opposite 15 V rails with separate 100 nanofarad bypass capacitors. Scope tips measure X, Y drive and output pin 7.
Change the pair of Y input connections with the outputs off. The X input, load and ground stay fixed. Full-size PNG · Editable schematic

Use the exact Analog Devices AD633JNZ eight-lead plastic dual in-line package (PDIP), package option N-8 in the Rev. K ordering guide. Use the notch and pin-1 mark to orient it. The small-outline integrated circuit has a different pin order. The older AD633JN designation in the top-view drawing refers to the PDIP pin functions. The manufacturer’s ordering guide lists AD633JNZ, and its later discontinuance notice lists JNZ as the replacement for JN.

PinConnection
1, X1Tektronix AFG1022 outlet 1 center through R1, 100 Ω. This point is X and also scope channel 1 (CH1).
2, X2G0. This makes the X difference equal to the voltage on pin 1.
3, Y1 and 4, Y2Use the three pairs below. Connect both pins before enabling either source.
5, −VS−15 V with C2, 100 nF ceramic rated at least 50 V, to G0 close to the pin.
6, ZG0. This additive input can shift the output. The experiment keeps it at zero.
7, WOutput to oscilloscope CH3, with R4, 10 kΩ, from W to G0.
8, +VS+15 V with C1, 100 nF ceramic rated at least 50 V, to G0 close to the pin.

Use a SIGLENT SPD3303X dual supply with independently isolated channels. Turn its internal series and parallel modes off. Before patching, set each channel to 15.00 V with a 35 mA limit, then turn both outputs off. Join channel 1 negative to channel 2 positive at G0. Channel 1 positive provides +15 V, and channel 2 negative provides −15 V. Verify polarity from G0 with a meter. The two generator cable shields and all oscilloscope probe grounds go only to G0. Earthing either outer rail through a probe clip would short that supply channel. Keep instrument protective earth intact. Enable the two supply channels and confirm both rails at the device before enabling either generator output.

AFG outlet 2 drives node Y drive through R2, 100 Ω. R3, 100 kΩ, ties that node to G0 in every state, including the disconnected control. Scope CH2 monitors Y drive at the same point in all three cases. Use ±1% 0.25 W resistors for R1–R4. Connect the Y leads as follows.

CSV modeY1, pin 3Y2, pin 4
positiveY driveG0
negativeG0Y drive
controlG0G0

Use both generator channels in High Z (high-impedance) display mode. Set sine, zero offset and 8 V peak-to-peak on each. Each ground-centered sine spans −4 V to +4 V. The generator source impedance is nominally 50 Ω. With the 100 Ω series resistor and 100 kΩ load at Y drive, plus the probe and multiplier input in parallel, the resistive drop is roughly 0.15%, or 6 mV peak. Treat that as a scale check. The actual input amplitudes and phases come from the two input channels in every capture.

The operating supply range in Rev. K is ±8 V to ±18 V. The same ±18 V appears as the supply stress ceiling. This fixture uses ±15 V, the datasheet’s specification condition at 25 °C and loads of at least 2 kΩ. A 10 kΩ load in parallel with a 10 MΩ probe is about 9.99 kΩ. At the nominal 1.6 V upper bound of the ideal instantaneous product, it draws about 0.16 mA. The 4 V input magnitude is also inside the ±10 V differential and common-mode ranges at the table conditions. When one differential input is driven and the other grounded, its common-mode voltage is half the applied waveform, about ±2 V. Keep the J-grade device at room temperature. The datasheet states its general total error relative to full scale, so a percentage there cannot be applied directly to a sub-volt sideband.

Predict the two new frequencies

Let the measured input waves be x(t) = A cos(2πfXt + φX) and y(t) = B cos(2πfYt + φY), with peak voltages A and B. The AD633 transfer equation with Z grounded is W = (X1 − X2)(Y1 − Y2)/(10 V). With Y drive on Y1, multiplying the two cosines gives the sum of two cosines. Each has a peak amplitude of AB/(20 V).

Ideal product termFrequencyPhaseNominal magnitude
Difference1,700 − 1,000 = 700 HzφY − φX0.80 V peak
Sum1,700 + 1,000 = 2,700 HzφX + φY0.80 V peak

Putting Y drive on Y2 changes the sign of the whole product, equivalent to adding 180° to both output phases. The generator phases can start at different values for each record, so compare output phase to its own simultaneously recorded X and Y. Peaks at the two original frequencies are feedthrough in this circuit. They can arise from input offsets, coupling between wires or the multiplier itself. The control checks output tone amplitudes with both Y pins at G0 while the generator and its probe keep running. Small readings may remain.

Capture the signals together

  1. With supply and generator outputs off, inspect the notch, both rails and the two local bypass capacitors. Set the first Y lead pair and check that neither input can float while powered. Measure the two rails relative to G0. Stop if either differs from the nominal 15.00 V magnitude by more than 0.2 V or the supply enters current limit. Change Y wiring only after both sources are disabled and the rails have returned close to G0.
  2. Use a RIGOL DHO804 and three compensated 10× PVP2350 probes. Match the channel setting to the probe attenuation. Use direct-current coupling, ordinary sampling and one stopped acquisition from all three channels. Scope CH1 and CH2 set to about 2 V/div and CH3 to about 0.5 V/div are starting points. Choose offsets and ranges so all three traces are centered and visibly unclipped. Confirm input amplitudes close to 4 V peak. Use 1,000 Hz on outlet 1 and 1,700 Hz on outlet 2. Disable any unrelated modulation or sweep modes.
  3. Start at 10 ms/div and select a memory depth giving a measured time step between 5 and 50 µs. A 120 ms, 10,000-point acquisition gives roughly 12 µs per sample. Capture at least 60 ms of continuous samples per state. Record one positive, one negative and one control waveform set. Preserve the three channels’ common time axis. Check raw traces for clipping, ground errors and generator amplitude changes before comparing the product.
  4. Export Memory waveforms as comma-separated values (CSV). Save the native records first. In an analysis copy use the blank worksheet header and replace the placeholder rows with the actual samples. Put time in seconds and voltages at the probe tips in volts. Apply the probe scale exactly once. Keep the time increasing within each state. The program accepts evenly spaced samples and small variations in spacing within the stated range. If an instrument export uses finer spacing, recapture with a suitable memory depth or export an uninterrupted regularly selected subset after checking the native record.

Fit the two products and the two inputs

Run python3 ad633_mixer.py observations.csv. The analyzer uses least squares, which solves for a constant plus cosine and sine terms that minimize the squared difference from the waveform samples. It fits 700 Hz, 1,000 Hz, 1,700 Hz and 2,700 Hz together, so a waveform need not end exactly on a whole cycle. A complex number called a phasor represents a tone’s peak voltage and phase. For cosine coefficient C and sine coefficient S the program uses C − jS, where j² = −1. The predicted sum phasor is sign × X × Y / 20. For the difference, use sign × Y × conjugate(X) / 20; conjugating X changes the sign of its phase.

The analyzer reports all four output magnitudes, the predicted sum and difference from the measured inputs, the measured/predicted amplitude ratios and individual phase errors. For this fixture it screens each driven input at 3.8–4.2 V peak and checks offset, leakage into the other fitted bands, and residual. Each active product should have 0.75–1.25 of its prediction and no more than 20° phase error. The control bands must stay at or below 0.10 V peak. Output at either original frequency must stay at or below 0.15 V peak. The residual is the part of the original trace left after subtracting all fitted terms, and the checks include a 0.12 V root-mean-square residual ceiling for every waveform. These tolerances are experiment screens. The fit is restricted to four declared frequencies and does not measure the spectrum outside them. Unexpected frequency drift or other content may raise the residual. Check the raw trace and instrument settings.

Exit 0 says all three recorded states support the expected product and polarity within the fixture screens. Exit 3 includes the recorded ratios and reasons when the comparison is unresolved. Exit 2 means the file violates the required format or capture limits. As a fault exercise, submit a copy of the positive capture as negative, retaining the other two captures. A wrong sign changes the relative phase by roughly 180° even though the magnitudes stay the same. Keep your original files and do not enter synthetic results as bench measurements.

Complete analyzer

Download the Python analyzer or download the editable fixture, worksheet and synthetic host tests. The code uses the standard library.

#!/usr/bin/env python3
"""Fit known sum, difference and feedthrough tones in three AD633 captures."""
import argparse
import cmath
import csv
import json
import math
from pathlib import Path


HEADER = ("mode", "time_s", "x_drive_v", "y_drive_v", "w_v")
MODES = {"positive": 1, "negative": -1, "control": 0}
BANDS = (700, 1000, 1700, 2700)


def read_captures(path):
    captures = {name: [] for name in MODES}
    with path.open(encoding="utf-8-sig", newline="") as stream:
        rows = csv.reader(stream, strict=True)
        if tuple(next(rows, ())) != HEADER:
            raise ValueError("Wrong CSV header. Expected " + ",".join(HEADER))
        for row in rows:
            line = rows.line_num
            if len(row) != len(HEADER) or row[0] not in captures:
                raise ValueError(f"Bad mode or field count on line {line}")
            values = tuple(map(float, row[1:]))
            if not all(math.isfinite(x) for x in values):
                raise ValueError(f"Nonfinite sample on line {line}")
            t, x, y, w = values
            if abs(t) > 10 or max(abs(x), abs(y), abs(w)) > 20:
                raise ValueError(f"Sample outside input domain on line {line}")
            points = captures[row[0]]
            if len(points) >= 30_000:
                raise ValueError("Capture exceeds 30,000 rows")
            if points and not 0.000005 - 1e-12 <= t - points[-1][0] <= 0.00005 + 1e-12:
                raise ValueError(f"Expected increasing time in 5–50 µs steps on line {line}")
            points.append(values)

    for mode, points in captures.items():
        if len(points) < 2 or points[-1][0] - points[0][0] < .060 - 1e-12:
            raise ValueError(f"{mode}: need at least 60 ms of continuous capture")
    return captures


def basis(t):
    values = [1.0]
    for f in BANDS:
        angle = math.tau * f * t
        values.extend((math.cos(angle), math.sin(angle)))
    return values


def solve(matrix, vector):
    """Solve a small dense system with partial pivoting."""
    rows = [line + [rhs] for line, rhs in zip(matrix, vector)]
    n = len(rows)
    for col in range(n):
        pivot = max(range(col, n), key=lambda i: abs(rows[i][col]))
        rows[col], rows[pivot] = rows[pivot], rows[col]
        value = rows[col][col]
        if abs(value) < 1e-10:
            raise ValueError("Capture samples do not resolve the tone fit")
        rows[col] = [x / value for x in rows[col]]
        for i in range(n):
            if i != col:
                factor = rows[i][col]
                rows[i] = [x - factor * y for x, y in zip(rows[i], rows[col])]
    return [row[-1] for row in rows]


def fit(bases, samples):
    """Fit DC, cosine and sine terms simultaneously; return peak phasors."""
    columns = tuple(zip(*bases))
    gram = [[math.fsum(a * b for a, b in zip(left, right))
             for right in columns] for left in columns]
    rhs = [math.fsum(a * b for a, b in zip(column, samples)) for column in columns]
    coef = solve(gram, rhs)
    bands = {f: complex(coef[2 * i + 1], -coef[2 * i + 2])
             for i, f in enumerate(BANDS)}
    error = math.fsum(
        (sample - math.fsum(a * b for a, b in zip(row, coef))) ** 2
        for row, sample in zip(bases, samples)
    )
    return coef[0], bands, math.sqrt(error / len(samples))


def analyze(mode, points):
    t, x, y, w = zip(*points)
    bases = [basis(value - t[0]) for value in t]
    x_dc, x_bands, x_rms = fit(bases, x)
    y_dc, y_bands, y_rms = fit(bases, y)
    w_dc, w_bands, w_rms = fit(bases, w)
    x_tone = x_bands[1000]
    y_tone = y_bands[1700]
    reasons = []
    for label, dc, phasor, rms, bands, target in (
        ("X", x_dc, x_tone, x_rms, x_bands, 1000),
        ("Y drive", y_dc, y_tone, y_rms, y_bands, 1700),
    ):
        other = max(abs(v) for f, v in bands.items() if f != target)
        if abs(dc) > .15 or not 3.8 <= abs(phasor) <= 4.2 or max(rms, other) > .12:
            reasons.append(f"{label} is outside the sine input screen")
    if max(map(abs, x + y)) > 5.2 or max(map(abs, w)) > 4:
        reasons.append("capture exceeds the fixture voltage screen")
    if abs(w_dc) > .20 or w_rms > .12:
        reasons.append("output offset or residual is too large")
    if max(abs(w_bands[1000]), abs(w_bands[1700])) > .15:
        reasons.append("feedthrough exceeds 0.15 V peak")

    sign = MODES[mode]
    expected = {700: sign * y_tone * x_tone.conjugate() / 20,
                2700: sign * x_tone * y_tone / 20}
    output = {}
    for freq, actual in w_bands.items():
        prediction = expected.get(freq)
        row = {"amplitude_peak_v": abs(actual)}
        if prediction is not None:
            row["predicted_peak_v"] = abs(prediction)
            if abs(prediction) > .01 and abs(actual) > .01:
                ratio = abs(actual / prediction)
                phase = math.degrees(cmath.phase(actual / prediction))
                row.update(amplitude_ratio=ratio, phase_error_deg=phase)
                if not .75 <= ratio <= 1.25 or abs(phase) > 20:
                    reasons.append(f"{freq} Hz amplitude or phase misses the product screen")
            elif sign:
                reasons.append(f"{freq} Hz product could not be resolved")
            if not sign and abs(actual) > .10:
                reasons.append(f"{freq} Hz remains above the control threshold")
        output[str(freq)] = row

    return {"sample_count": len(points), "output_bands": output,
            "input_peak_v": [abs(x_tone), abs(y_tone)],
            "input_offset_v": [x_dc, y_dc],
            "input_residual_rms_v": [x_rms, y_rms],
            "output_offset_v": w_dc, "output_residual_rms_v": w_rms, "reasons": reasons}


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("captures", type=Path)
    args = parser.parse_args()
    try:
        if args.captures.stat().st_size > 8 * 1024 * 1024:
            raise ValueError("CSV exceeds 8 MiB")
        reports = {mode: analyze(mode, data) for mode, data in read_captures(args.captures).items()}
    except (OSError, ValueError, csv.Error) as error:
        parser.exit(2, f"Input error: {error}\n")
    supported = all(not row["reasons"] for row in reports.values())
    print(json.dumps({"outcome": "mixing_supported" if supported else "unresolved",
                      "modes": reports}, indent=2, allow_nan=False))
    return 0 if supported else 3


if __name__ == "__main__":
    raise SystemExit(main())

Challenge

If X drops from 4 V to 2 V peak while Y stays at 4 V, what happens to the product?

The sum and difference remain at 2,700 and 700 Hz. Their nominal amplitudes halve to 0.40 V peak. Adjust the analysis limits before comparing a different experiment, since the delivered analyzer expects two approximately 4 V inputs.

Primary sources

Compare this circuit with the passive two-tone summing experiment, where a linear network retains the original frequencies, or explore the role of a detector in a CD4046B phase-locked loop.