INA826: Make Common-Mode Voltage Appear at the Output

Connect both inputs of an instrumentation amplifier to the same changing voltage. With zero difference between them, the output should stay close to its reference. Now insert 100 kΩ in series with the reference pin and repeat. The Texas Instruments INA826 uses matched resistor ratios to reject the voltage shared by its inputs. This experiment shows how the circuit feeding one pin can upset that balance.

Build the unity-gain fixture

Use the exact INA826AIDGKR, a Texas Instruments INA826 in the DGK eight-lead very small-outline package (VSSOP-8). Use OPA333AIDBVR in the DBV five-lead small-outline transistor package (SOT-23-5) for the reference buffer. Both run from the fixture’s 5.00 V supply. The INA826’s recommended single supply is 3–36 V and the OPA333 operates at 1.8–5.5 V. The OPA333’s 5.5 V operating ceiling applies to the shared rail. Check each manufacturer top view against its adapter. The drawing below is a functional pin map.

The INA826 inputs share one adjustable node. An OPA333 buffers a 10 kilohm divider at half the 5 volt rail. A removable link shorts the 100 kilohm resistor from buffer output to INA826 REF pin 6. Each chip has a 100 nanofarad bypass capacitor. All returns share G0.
Fit the link for direct reference drive. Remove it to insert 100 kΩ while keeping the buffer, supply and input wiring unchanged.

Download the editable schematic or download the complete experiment files.

Exact pin connections
DevicePin or pairConnection
INA8261 −IN, 4 +INTie both directly to the common-input node from channel 2.
INA8262, 3 RGLeave both open for gain 1.
INA8265 −VS, 8 +VSPin 5 to G0, pin 8 to 5.00 V, 100 nF ceramic directly across them.
INA8266 REF, 7 OUTREF through 100 kΩ to buffer output. A removable link shorts that resistor. Measure OUT at pin 7.
OPA3331 OUT, 4 −INConnect together at VREF source, before the 100 kΩ resistor.
OPA3333 +INMidpoint of two 10.0 kΩ 1% resistors between 5.00 V and G0.
OPA3332 V−, 5 V+Pin 2 to G0, pin 5 to 5.00 V, 100 nF ceramic directly across them.

Use short wires or a soldered breakout, a SIGLENT SPD3303X supply in independent channel mode and a Fluke 115 digital multimeter (DMM). Both supply negative terminals and meter COM share G0. With both outputs off, wire channel 1 to the 5.00 V rail and channel 2 to the tied inputs. Program each channel’s current setting to 20 mA. Turn on channel 1 first. Confirm the 5 V rail and the buffer output near 2.50 V, then enable channel 2. Switch off both outputs before changing the link and disable channel 2 first. Leave pin 6 unprobed, since a meter there becomes part of the intentional series-resistance experiment. Keep OUT free of external loads except the meter.

Predict the effect of the reference arm

Common-mode voltage is the average of the two input voltages. Differential voltage is the voltage on +IN minus that on −IN. This fixture ties the inputs to one node, so their differential voltage is zero. Both input amplifiers still move internally as the shared voltage changes. Texas Instruments shows that their equal internal outputs are roughly 0.8 V above the shared voltage in this case. The external 0.75–2.25 V sweep keeps the ideal internal outputs around 1.55–3.05 V, away from either rail. The data sheet explains why an amplifier can also overload internally even when its external output looks plausible.

The last stage is a difference amplifier with four nominal 50 kΩ arms, as shown in Figure 58. Call the two equal internal voltages A and the buffer output VB. At the final stage’s positive input, one arm goes through 50 kΩ to A and the other through 50 kΩ plus the added resistance RS to VB. The negative feedback stage gives VOUT = 2V+ − A. For these equal inputs the resulting simplified model is:

VOUT ≈ VB + [RS ÷ (100 kΩ + RS)] × (A − VB)

With the link fitted, RS is close to zero and the output stays near VB. With the link removed, 100 kΩ gives a nominal slope of 0.5 volt of output change per volt of common-mode change. For a 1.50 V input span that is about 0.75 V of output span. Using a nominal 2.50 V buffer and the approximate 0.8 V internal offset gives output examples of 2.025, 2.400 and 2.775 V. Those are calculations. The slope comparison does not require that the internal offset be exactly 0.8 V.

TI recommends less than 5 Ω source impedance at REF for best performance. The buffer supplies a low-impedance DC reference, and the test resistor is intentionally far above that recommendation. The resistor makes the final stage respond to a shared input change even though the two inputs remain tied. This is a fixture demonstration of the external resistance effect. It does not measure the amplifier’s specified common-mode rejection ratio (CMRR), which characterizes rejection under stated data-sheet conditions.

Measure direct, series and direct again

  1. On the Fluke 115 select the fixed 6.000 V direct-current range and the voltage jack. In this range each count is 1 mV and the specified accuracy is ±(0.5% of reading plus two counts). Use the manual’s 18–28 °C, 0–90% relative humidity and within-one-year calibration conditions. Keep COM at G0. Use short, clean meter leads.
  2. Fit the reference link with power off. Set the common input to 0.75, 1.50 and 2.25 V. At each point wait for stable readings, then record actual 5 V rail, tied input, buffer output and INA826 output in direct. Read the buffer at the source side of the resistor, not pin 6. Keep the shared rail within 4.90–5.10 V and each input within ±30 mV of target.
  3. Turn off channel 2, then channel 1. Remove only the link. Power back up in the original order and repeat the three common inputs in series_100k. Restore the link with both channels off and repeat as direct_repeat. Keep the rail, meter, component positions and loads the same.
  4. Fill the nine-row worksheet with your measured volts. Stop to diagnose a missing bias connection, unstable supply or output closer than 0.40 V to either rail. The deliberately large series resistance should make the change easy to see with ordinary voltage readings.

Check the trend and the restored control

The analyzer forms the high-to-low output slope from the measured common input span. It expands the endpoint readings by the meter allowance and reports the extreme slope ratios using positive input-span endpoints. The two direct slope intervals must fit inside −0.04 to +0.04 V/V, and their corresponding outputs must agree within 35 mV. Direct output must stay within 50 mV of the buffer voltage. The series slope interval must fit within +0.35 to +0.65 V/V, and the middle output must be within 60 mV of the line between measured endpoints. The worksheet also checks reference, supply and input matching between runs. These are experiment screens, with the guard on the measured slopes distinct from the nominal model.

Challenge: If the tied inputs rise by 0.50 V with 100 kΩ inserted, what changes?

The nominal common-mode slope is 0.5 V/V. OUT should rise by about 0.25 V even though the two inputs still differ by zero volts. The internal arm ratio has changed while the buffer source stays near 2.50 V.

Run the complete worksheet analyzer

Run python3 ref_sweep.py observations-filled.csv. Exit 0 means the experiment screens passed, exit 3 reports a complete set with one or more unresolved screens, and exit 2 reports invalid input. All supplied tests use constructed readings. The blank worksheet contains no physical measurements.

Complete Python reference sweep analyzer
"""Compare INA826 common-mode slopes before, during and after adding REF resistance."""

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

FIELDS = ("run", "level", "rail_v", "cm_v", "ref_source_v", "out_v")
RUNS = ("direct", "series_100k", "direct_repeat")
LEVELS = (("low", .75), ("middle", 1.50), ("high", 2.25))
EPS = 1e-12


def numeric(raw):
    value = float(raw)
    if not math.isfinite(value):
        raise ValueError("enter finite voltages")
    return value


def meter_span(value):
    allowance = .005 * abs(value) + .002
    return value - allowance, value + allowance


def difference(left, right):
    a, b = meter_span(left)
    c, d = meter_span(right)
    return a - d, b - c


def slope_interval(first, last):
    cm_low, cm_high = difference(last["cm_v"], first["cm_v"])
    out_low, out_high = difference(last["out_v"], first["out_v"])
    values = [out / cm for out in (out_low, out_high) for cm in (cm_low, cm_high)]
    return min(values), max(values)


def read_data(stream):
    reader = csv.reader(stream, strict=True)
    if tuple(next(reader, ())) != FIELDS:
        raise ValueError("use the exact worksheet headings")
    data = {}
    for name in RUNS:
        rows = []
        for level, target in LEVELS:
            row = next(reader, ())
            if len(row) != 6 or tuple(row[:2]) != (name, level):
                raise ValueError(f"expected {name}, {level}")
            rail, cm, reference, output = map(numeric, row[2:])
            if not 4.90 <= rail <= 5.10:
                raise ValueError(f"{name}, {level}: rail outside 4.90–5.10 V")
            if abs(cm - target) > .030 + EPS:
                raise ValueError(f"{name}, {level}: common input outside target ±30 mV")
            if not 2.40 <= reference <= 2.60 or not .40 <= output <= rail - .40 + EPS:
                raise ValueError(f"{name}, {level}: check reference and output headroom")
            rows.append(dict(zip(FIELDS[2:], (rail, cm, reference, output))))
        data[name] = rows
    if next(reader, None) is not None:
        raise ValueError("unexpected additional worksheet row")
    return data


def describe(rows):
    first, middle, last = rows
    cm_span = last["cm_v"] - first["cm_v"]
    out_span = last["out_v"] - first["out_v"]
    slope = out_span / cm_span
    middle_residual = middle["out_v"] - (first["out_v"] + slope * (middle["cm_v"] - first["cm_v"]))
    return {
        "common_mode_span_v": cm_span, "output_span_v": out_span,
        "nominal_output_slope_v_per_v": slope, "meter_slope_interval_v_per_v": slope_interval(first, last),
        "measured_middle_residual_v": middle_residual,
    }


def analyze(stream):
    rows = read_data(stream)
    descriptions = {name: describe(values) for name, values in rows.items()}
    direct, series, repeat = (descriptions[name] for name in RUNS)
    all_rows = [r for values in rows.values() for r in values]
    reference = [r["ref_source_v"] for r in all_rows]
    rails = [r["rail_v"] for r in all_rows]
    direct_rows = rows["direct"] + rows["direct_repeat"]
    series_range = series["meter_slope_interval_v_per_v"]
    checks = {
        "measured_reference_source_span_at_most_20_mv": max(reference) - min(reference) <= .020 + EPS,
        "measured_supply_span_at_most_100_mv": max(rails) - min(rails) <= .100 + EPS,
        "common_input_levels_match_within_30_mv": all(
            max(item["cm_v"] for item in points) - min(item["cm_v"] for item in points) <= .030 + EPS
            for points in zip(*(rows[name] for name in RUNS))),
        "both_direct_slope_intervals_inside_plus_minus_0p04": all(
            low >= -.04 - EPS and high <= .04 + EPS
            for low, high in (direct["meter_slope_interval_v_per_v"], repeat["meter_slope_interval_v_per_v"])),
        "direct_output_near_source_within_50_mv": all(
            abs(r["out_v"] - r["ref_source_v"]) <= .050 + EPS for r in direct_rows),
        "direct_repeat_matches_within_35_mv": all(
            abs(a["out_v"] - b["out_v"]) <= .035 + EPS for a, b in zip(rows["direct"], rows["direct_repeat"])),
        "series_slope_interval_inside_0p35_to_0p65": series_range[0] >= .35 - EPS and series_range[1] <= .65 + EPS,
        "series_middle_residual_at_most_60_mv": abs(series["measured_middle_residual_v"]) <= .060 + EPS,
    }
    return {"all_checks_pass": all(checks.values()), "checks": checks,
            "series_nominal_common_mode_slope_v_per_v": .5, "measurements": rows, "runs": descriptions}


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("worksheet", type=Path)
    args = parser.parse_args()
    try:
        if args.worksheet.stat().st_size > 8192:
            raise ValueError("one nine-row worksheet, at most 8 KiB")
        with args.worksheet.open(encoding="utf-8-sig", newline="") as stream:
            report = analyze(stream)
    except (OSError, csv.Error, ValueError) as error:
        print(f"Worksheet rejected: {error}", file=sys.stderr)
        return 2
    print(json.dumps(report, indent=2, allow_nan=False))
    return 0 if report["all_checks_pass"] else 3


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

Primary references