Measure How Excitation Warms a Glass Thermistor

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.

Identify the thermistor and its conditions

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.

Wire the sensor and both voltmeters

  1. Use an isolated SIGLENT SPD3303X channel 1 output in independent mode. With output disabled, connect channel positive to VS+ and negative to G0. Use a 2.20 kΩ, 1%, 0.25 W metal-film resistor from VS+ to MID. Connect the glass thermistor from MID to G0. It has two interchangeable electrical leads. Leave the other supply channels disconnected and set the current limit to 0.03 A. Confirm the supply remains in constant-voltage operation.
  2. Use two battery-powered Fluke 115 digital multimeters on the fixed 6.000 V direct-current (DC) range. Meter A reads across the series resistor, with red at VS+ and black at MID. Meter B reads across the thermistor, with red at MID and black at G0. Use their voltage and common (COM) jacks and keep the meters floating. Connecting the black leads together would join MID to G0.
  3. Support the two leads on an insulating fixture so the bead stays above the base and clear of drafts, hands and warm equipment. Use the same support positions and wiring for every thermistor trace. Avoid bending at the glass seal. If the leads must be formed, support them and follow the manufacturer's lead-forming precautions. Put a room thermometer near the bead, leaving a gap so it cannot conduct heat into it. Use the thermometer as a drift check. Place a 10 kΩ, 1%, 0.25 W metal-film resistor at MID and G0 only for the separate control run.
The source feeds a 2.20 kilohm resistor in series with a glass thermistor or fixed control. Meter A measures VS plus to MID and meter B measures MID to G0. An inset shows the bead suspended by its leads above an insulating base.
Meter A reads the series drop and Meter B reads the device drop. The thermistor bead stays clear of the supports. Full-size PNG · Editable SVG.

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.

Record one low–high–low sequence per device

  1. Set 1.80 V and start a timer once the voltage is set. Wait until the first late record at about 80 s, then record both voltages and nearby air temperature at 80, 90 and 100 s. Check that the two drops add to about 1.80 V. Keep the meters on the same ranges for the whole run.
  2. Leave the bead in place. Raise the set voltage to 5.80 V without changing the wiring. Start the next timer when the new voltage is applied. For timed interpretation make the setpoint change in about one second or less. Record early pairs at roughly 5, 15, 30 and 60 s and late pairs at 80, 90 and 100 s. If the late ratio continues to drift, wait and add more readings. Record the actual times.
  3. Return to 1.80 V and start the recovery timer at the new setting. Aim for readings at 3, 6, 10, 15, 20, 30, 45 and 60 s, then take three late readings at 80, 90 and 100 s. A recording of the two displays and a running timer can help you transcribe close pairs. If the step was slow or the displays were read too far apart, run the endpoint comparison with --untimed. Repeat the sequence for a timed comparison.
  4. Disable the output and replace the NTC with the fixed resistor without changing the meters, series resistor or set voltages. Repeat the three phases. The control needs only the late readings. Use the same air and equipment settings. Copy the planned rows from the blank worksheet, using actual seconds and entering values only from your run.

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.

Compare ratios and estimate power

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.

Challenge. Both devices change with supply setting. What is the next check?

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.

Run the complete worksheet analyzer

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.

Complete Python worksheet analyzer
"""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.

References