A resistance measurement sends power into the sensor. A negative temperature coefficient (NTC) thermistor decreases in resistance as it warms, so a higher measurement voltage can shift the reading even in a steady room. Leave one glass bead in place, raise its excitation, then return to the original voltage. Repeat the same sequence with a fixed resistor to check for changes in the measurement circuit.
Observe both voltage drops and the cooling trace. The experiment looks for a reversible pattern consistent with self-heating. A room thermometer and a fixed resistor help identify competing explanations. They cannot establish the exact air temperature at the bead or separate every effect of the fixture.
Use the TDK Electronics glass-encapsulated B57560G1103G000 with radial leads, type G1560. It is nominally 10 kΩ at 25 °C, with ±2% resistance tolerance for this suffix. The manufacturer lists a 3492 K nominal B value from 25 to 100 °C. This parameter summarizes the slope of the resistance curve over that interval. Near 25 °C, the manufacturer's resistance/temperature curve 8307 gives a resistance change of about −3.9% per kelvin. The experiment uses ratios and that approximate slope for planning.
The G1560 data sheet gives 50 mW maximum power at 25 °C and an approximate air dissipation factor of 1.3 mW/K. A dissipation factor is the power needed per degree of steady temperature rise under a stated thermal setup. The same sheet gives an approximate 15 s cooling time constant in air. A time constant describes how quickly an ideal exponential approaches its final value. Lead length, supports and air movement affect this experiment, so use those values to plan the sequence.
At the nominal 10 kΩ room-temperature point, 1.80 V gives about 0.148 mA and 0.218 mW in the bead. At 5.80 V the same resistance would give 0.475 mA and 2.26 mW. The 2.04 mW difference and the data-sheet dissipation factor suggest about 1.6 K of additional rise under its stated air conditions. Near 25 °C that could shift the resistance by roughly 6%. These are planning calculations with a fixed starting resistance. The actual resistance and dissipation change while the bead warms. In the ideal series model, even 6.00 V across the circuit with the smallest 1% series resistor gives a maximum device power of 6.00² ÷ (4 × 2178) W, or about 4.13 mW.
--untimed. Repeat the sequence for a timed comparison.Keep the meters within their stated accuracy conditions, which for these Fluke specifications include 18–28 °C, up to 90% relative humidity and one year after calibration. The program screens the measured voltage sums within 0.10 V of the selected setting and the indicated ambient spread within 0.50 °C. A 0.50 °C air change could itself shift this NTC by about 2% near room temperature. Treat the ambient screen as a check for drift. Shield the bead from room changes and repeat the sequence if the environment moved.
With VS across the series resistor RS and VD across the device, estimate current as VS ÷ RS and device power as VD × VS ÷ RS. Use the voltage ratio q = VD ÷ VS to follow resistance, because the nominal device resistance is q × RS. The same series resistor is used in every phase.
The power estimate neglects the meters' small input currents. For the ratio bounds, the program allows the Fluke 115 voltage uncertainty, 0.5% of each reading plus two 1 mV counts, and input resistances above 10 MΩ. When including meter loading, current through the device equals VS ÷ RS + VS ÷ RA − VD ÷ RB. The second term enters through Meter A and the third bypasses the device through Meter B. These bounds cover the instrument model. Keep the same leads and contacts for the comparison. The four-wire resistance experiment shows what changes when the sense points move.
The analyzer uses at least three readings at 80 s or later in each phase, spanning at least 20 s. The worksheet accepts elapsed times through 180 s. It checks that the largest and smallest late ratios differ by no more than 1% of their median. It reports whether the control's three late intervals share an overlap and whether the thermistor's hot interval lies below both of its overlapping low-power intervals. A reversible pattern with a stable indicated ambient is consistent with excitation heating. The matched control and ambient readings narrow the explanations, and the bead's immediate air and support temperatures still matter.
The optional half-recovery bracket measures the time needed to pass halfway from the hot resistance ratio to the recovered ratio. It takes the last sampled ratio definitely below the midpoint interval and the first sampled ratio definitely above it. A later definite reversal or a bracket wider than 30 s leaves the timing unresolved. The two times describe this sampled resistance response under low-power excitation. The manufacturer's cooling time constant uses a different definition.
Compare the two voltmeter ranges, polarities and connections, and look for a loose or shifted sense point. Repeat the fixed-resistor sequence before relating the thermistor's change to heating. A stable resistor control is one check on the fixture.
Download the experiment ZIP with the blank comma-separated values (CSV) worksheet, diagrams, complete program and host tests. Run python3 ntc_self_heat.py observations.csv. If you measured the series resistor separately, add --series-ohms followed by its measured value within the fixture's tolerance. That value affects the nominal power calculation. The tests use constructed inputs. Enter actual air and voltage readings only from the bench.
"""Compare thermistor excitation and recovery with a fixed-resistor control."""
import argparse
import csv
from dataclasses import dataclass
import json
import math
from pathlib import Path
from statistics import median
import sys
FIELDS = ("device", "phase", "time_s", "series_v", "device_v", "ambient_c")
DEVICES = ("ntc", "control")
PHASES = ("baseline", "heated", "recovery")
RAILS = {"baseline": 1.80, "heated": 5.80, "recovery": 1.80}
MIN_METER_INPUT_OHMS = 10_000_000.0
MAX_SERIES_OHMS = 2222.0
EPS = 1e-10
@dataclass(frozen=True)
class Reading:
time_s: float
series_v: float
device_v: float
ambient_c: float
ratio: float
ratio_low: float
ratio_high: float
inferred_power_mw: float
def bounded(raw, low, high, name):
try:
value = float(raw)
except (TypeError, ValueError):
raise ValueError(f"{name}: enter a number") from None
if not math.isfinite(value) or not low <= value <= high:
raise ValueError(f"{name}: expected {low:g} to {high:g}")
return value
def meter_limits(volts):
error = 0.005 * volts + 0.002
return volts - error, volts + error
def reading(phase, values, series_ohms):
elapsed = bounded(values[0], 0, 180, "time_s")
series = bounded(values[1], 0.10, 2.5, "series_v")
device = bounded(values[2], 0.50, 5.8, "device_v")
ambient = bounded(values[3], 18, 28, "ambient_c")
if abs(series + device - RAILS[phase]) > 0.10 + EPS:
raise ValueError("voltage sum differs from the selected rail by more than 0.10 V")
nominal_ratio = device / series
if not 2.0 - EPS <= nominal_ratio <= 9.0 + EPS:
raise ValueError("device-to-series voltage ratio outside the fixture's 2–9 screen")
series_low, series_high = meter_limits(series)
device_low, device_high = meter_limits(device)
observed_low = device_low / series_high
observed_high = device_high / series_low
loading = MAX_SERIES_OHMS / MIN_METER_INPUT_OHMS
ratio_low = observed_low / (1 + loading)
ratio_high = observed_high / (1 - loading * observed_high)
return Reading(elapsed, series, device, ambient, nominal_ratio, ratio_low, ratio_high,
1000 * device * series / series_ohms)
def read_worksheet(stream, series_ohms):
rows = csv.reader(stream, strict=True)
if tuple(next(rows, ())) != FIELDS:
raise ValueError("use the exact worksheet headings")
points = {(device, phase): [] for device in DEVICES for phase in PHASES}
for row in rows:
key = tuple(row[:2])
if len(row) != len(FIELDS) or key not in points:
raise ValueError(f"row {rows.line_num}: unexpected device, phase or field count")
try:
item = reading(key[1], row[2:], series_ohms)
group = points[key]
if group and item.time_s <= group[-1].time_s:
raise ValueError("timestamps must increase within each device and phase")
group.append(item)
except ValueError as error:
raise ValueError(f"row {rows.line_num}: {error}") from None
return points
def late_summary(rows):
late = [row for row in rows if row.time_s >= 80]
if len(late) < 3 or late[-1].time_s - late[0].time_s < 20 - EPS:
raise ValueError("each device and phase needs at least three late rows from 80 s spanning 20 s")
middle = median(row.ratio for row in late)
spread = max(row.ratio for row in late) - min(row.ratio for row in late)
return {
"rows": len(late),
"time_span_s": [late[0].time_s, late[-1].time_s],
"nominal_resistance_ratio": middle,
"ratio_bounds": [median(row.ratio_low for row in late), median(row.ratio_high for row in late)],
"nominal_device_power_mw": median(row.inferred_power_mw for row in late),
"observed_ratio_spread_percent": 100 * spread / middle,
"settled_by_one_percent_screen": spread <= 0.01 * middle + EPS,
}
def overlap(intervals):
return max(item[0] for item in intervals) <= min(item[1] for item in intervals) + EPS
def half_recovery(rows, heated, cooled):
midpoint = [(h + c) / 2 for h, c in zip(heated, cooled)]
first_above = next((i for i, row in enumerate(rows) if row.ratio_low > midpoint[1] + EPS), None)
outcome = {"midpoint_ratio_interval": midpoint, "bracket_s": None}
if first_above is None:
return dict(outcome, status="no_sample_definitely_above")
below_before = [row.time_s for row in rows[:first_above] if row.ratio_high < midpoint[0] - EPS]
if not below_before:
return dict(outcome, status="no_earlier_sample_definitely_below")
if any(row.ratio_high < midpoint[0] - EPS for row in rows[first_above + 1:]):
return dict(outcome, status="definite_reversal_after_crossing")
high_time = rows[first_above].time_s
low_time = below_before[-1]
if high_time - low_time > 30 + EPS:
return dict(outcome, status="sampling_bracket_wider_than_30_s")
return dict(outcome, status="bracketed", bracket_s=[low_time, high_time])
def analyze(stream, series_ohms=2200.0, *, timed=True):
series_ohms = bounded(series_ohms, 2178, 2222, "series resistance in ohms")
points = read_worksheet(stream, series_ohms)
summaries = {}
for device, phase in points:
try:
summaries[device, phase] = late_summary(points[device, phase])
except ValueError as error:
raise ValueError(f"{device}/{phase}: {error}") from None
all_ambient = [row.ambient_c for group in points.values() for row in group]
ambient_span = [min(all_ambient), max(all_ambient)]
stable_ambient = ambient_span[1] - ambient_span[0] <= 0.50 + EPS
settled = all(summary["settled_by_one_percent_screen"] for summary in summaries.values())
fixed = [summaries["control", phase]["ratio_bounds"] for phase in PHASES]
control_overlap = overlap(fixed)
before, hot, after = (summaries["ntc", phase]["ratio_bounds"] for phase in PHASES)
recovered = overlap([before, after])
reduction = hot[1] < min(before[0], after[0]) - EPS
resolved = stable_ambient and settled and control_overlap and recovered and reduction
timing = {"status": "timing_disabled_for_sequence", "bracket_s": None}
if timed:
timing = half_recovery(points["ntc", "recovery"], hot, after) if resolved else {
"status": "endpoint_or_control_check_unresolved", "bracket_s": None}
return {
"assumed_series_ohms_for_nominal_power": series_ohms,
"ambient_span_c": ambient_span,
"ambient_screen_passed": stable_ambient,
"all_late_ratio_spreads_within_one_percent": settled,
"control_late_intervals_share_overlap": control_overlap,
"ntc_baseline_and_recovered_intervals_overlap": recovered,
"ntc_hot_interval_below_both_low_power_intervals": reduction,
"reversible_pattern_consistent_with_self_heating": resolved,
"half_recovery": timing,
"late": {device: {phase: summaries[device, phase] for phase in PHASES} for device in DEVICES},
"ntc_nominal_recovery_trace": [
{"time_s": row.time_s, "ratio": row.ratio, "ratio_bounds": [row.ratio_low, row.ratio_high]}
for row in points["ntc", "recovery"]
],
}
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("worksheet", type=Path)
parser.add_argument("--series-ohms", type=float, default=2200.0)
parser.add_argument("--untimed", action="store_true", help="skip the half-recovery timing bracket")
options = parser.parse_args()
try:
if options.worksheet.stat().st_size > 100_000:
raise ValueError("worksheet exceeds 100 kB")
with options.worksheet.open(encoding="utf-8-sig", newline="") as stream:
result = analyze(stream, options.series_ohms, timed=not options.untimed)
except (OSError, ValueError, csv.Error) as error:
print(f"Worksheet rejected: {error}", file=sys.stderr)
return 2
print(json.dumps(result, indent=2, allow_nan=False))
return 0
if __name__ == "__main__":
raise SystemExit(main())
For a different circuit that uses a low-power thermistor divider to estimate temperature, see A Two-Resistor Thermometer. This fixture uses TDK's glass bead and keeps the fixture in place while deliberately changing measurement power.