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.
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.

Download the editable schematic or download the complete experiment files.
| Device | Pin or pair | Connection |
|---|---|---|
| INA826 | 1 −IN, 4 +IN | Tie both directly to the common-input node from channel 2. |
| INA826 | 2, 3 RG | Leave both open for gain 1. |
| INA826 | 5 −VS, 8 +VS | Pin 5 to G0, pin 8 to 5.00 V, 100 nF ceramic directly across them. |
| INA826 | 6 REF, 7 OUT | REF through 100 kΩ to buffer output. A removable link shorts that resistor. Measure OUT at pin 7. |
| OPA333 | 1 OUT, 4 −IN | Connect together at VREF source, before the 100 kΩ resistor. |
| OPA333 | 3 +IN | Midpoint of two 10.0 kΩ 1% resistors between 5.00 V and G0. |
| OPA333 | 2 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.
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.
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.series_100k. Restore the link with both channels off and repeat as direct_repeat. Keep the rail, meter, component positions and loads the same.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.
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 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.
"""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())