The 6 V, 100 mA rating of this miniature lamp gives 60 Ω at the rated operating point. Use the same low-voltage fixture with the lamp and a 62 Ω resistor to see why that calculation gives only one point on the lamp's current–voltage curve. The lamp dissipates electrical power in a filament whose resistance changes as it warms.
Measure the voltage across the load and the voltage across a small series resistor. The series resistor is a shunt, which lets you infer current from its voltage drop. From four settled voltage pairs you can estimate the load's resistance, its electrical power and a slope between two points.
The highest supply setting is 5.50 V, with a 5.60 V acceptance limit for the sum of the two measured drops. The lamp voltage is lower because the shunt takes part of the supply voltage. At the nominal 0.12 A current setting, a nominal 10 Ω shunt would dissipate about 0.14 W. Including the SPD3303X specified current-setting error of 0.3% plus 10 mA and a 1% high shunt gives about 0.17 W as a steady-state bound. The 62 Ω comparison resistor would dissipate less than 0.52 W even if all 5.60 V were across its 1% low-tolerance value. Keep the bulb and resistor clear of the work surface and handle them after they cool.
Use the blank worksheet and enter load_v from Meter A and shunt_v from Meter B. The fixture checks that the two voltages add to within 0.04 V of the 0.20 V setting or within 0.10 V of the higher settings. Those windows and the 1.24 V shunt ceiling screen this worksheet for setup errors. They do not represent the supply’s current-limit specification. A reading of the lamp across its holder includes the holder contact drops, which matter most at low voltage.
Compute I ≈ VSH ÷ RSH for every row. The estimate neglects the small currents through the meters' approximately 10 MΩ inputs. Then compute the operating resistance R = VLOAD ÷ I and the estimated electrical power P = VLOAD × I. This is the ratio at one settled point.
The finite slope between the 3.50 V and 5.50 V source settings is ΔVLOAD ÷ ΔI. It describes a different quantity. Each end of that segment can have a different filament temperature. The slope is a secant through two settled points, so it does not give the instantaneous small-signal resistance of a filament at a fixed temperature.
The ideal 62 Ω control in series with a nominal 10 Ω shunt draws 5.50 V ÷ 72 Ω ≈ 76.39 mA at the highest setting. That puts about 4.736 V across the control and 0.764 V across the shunt. At 0.20 V the corresponding nominal values are 2.78 mA, 0.172 V and 0.028 V. These are calculated reference values. Compare the control with your measurements before drawing conclusions from the lamp. The nominal 6 V and 100 mA imply 60 Ω at the rating, but the voltage across this fixture's lamp stays below 6 V.
Download the experiment ZIP with the full diagram, worksheet and code. Run python3 lamp_curve.py observations.csv on a computer. The default shunt is 10.0 Ω with a 1% bound. A verified measured value and its tolerance can be passed with --shunt-ohms and --shunt-error-percent. Keep the actual shunt calibration and temperature changes in your bench notes.
The Fluke 115 specifies ±(0.5% of the reading + 2 counts) for DC volts. On the 6 V range each count is 1 mV. The stated accuracy applies within one year of calibration, from 18 to 28 °C and at 0 to 90% relative humidity. For the operating resistance, the code combines each voltage bound with the worst end of the shunt bound. It reports an increase only when the high point's lower resistance bound exceeds the small-excitation point's upper bound. It reports an unresolved slope if the positive voltage or current change cannot be established from those bounds. These are conservative instrument and shunt intervals. Drift, contact changes and departures from voltage regulation need separate checks.
#!/usr/bin/env python3
"""Estimate an incandescent lamp's settled I–V curve from two DC voltages."""
import argparse
import csv
import json
import math
from pathlib import Path
import sys
FIELDS = ("device", "point", "load_v", "shunt_v")
DEVICES = ("lamp", "resistor")
RAILS = {"small": 0.20, "low": 1.50, "middle": 3.50, "high": 5.50}
KEYS = {(device, point) for device in DEVICES for point in RAILS}
EPSILON = 1e-12
def bounded(raw, lower, upper, name):
try:
value = float(raw)
except (TypeError, ValueError):
raise ValueError(f"{name}: enter a number") from None
if not math.isfinite(value) or not lower <= value <= upper:
raise ValueError(f"{name}: expected {lower:g} to {upper:g}")
return value
def meter_bounds(volts):
# Fluke 115 on the 6 V DC range: 0.5% of reading plus 2 × 1 mV.
error = 0.005 * volts + 0.002
return volts - error, volts + error
def read_point(key, values, shunt_ohms, resistor_error):
_, point = key
load_v = bounded(values[0], 0.001, 5.60, "load_v")
shunt_v = bounded(values[1], 0.001, 1.24, "shunt_v")
source_v = load_v + shunt_v
allowable = 0.04 if point == "small" else 0.10
if abs(source_v - RAILS[point]) > allowable + EPSILON:
raise ValueError("load and shunt voltages do not add to the selected rail")
load_low, load_high = meter_bounds(load_v)
shunt_low, shunt_high = meter_bounds(shunt_v)
if load_low <= 0 or shunt_low <= 0:
raise ValueError("a voltage is too close to zero for this meter range")
current = shunt_v / shunt_ohms
current_low = shunt_low / (shunt_ohms * (1 + resistor_error))
current_high = shunt_high / (shunt_ohms * (1 - resistor_error))
return {
"estimated_source_v": source_v,
"load_v": load_v,
"load_v_bounds": [load_low, load_high],
"shunt_v": shunt_v,
"estimated_current_a": current,
"estimated_current_bounds_a": [current_low, current_high],
"operating_resistance_ohms": load_v / current,
"operating_resistance_bounds_ohms": [load_low / current_high, load_high / current_low],
"load_power_w": load_v * current,
}
def parse_worksheet(stream, shunt_ohms, resistor_error):
reader = csv.reader(stream, strict=True)
if tuple(next(reader, ())) != FIELDS:
raise ValueError("use the exact worksheet headings")
observations = {}
for line, row in enumerate(reader, 2):
key = tuple(row[:2])
if len(row) != len(FIELDS) or key not in KEYS:
raise ValueError(f"line {line}: invalid device, point or column count")
if key in observations:
raise ValueError(f"line {line}: repeated observation {key}")
try:
observations[key] = read_point(key, row[2:], shunt_ohms, resistor_error)
except ValueError as error:
raise ValueError(f"line {line}: {error}") from error
if observations.keys() != KEYS:
raise ValueError("need all eight observations")
return observations
def segment_slope(left, right):
i_left_low, i_left_high = left["estimated_current_bounds_a"]
i_right_low, i_right_high = right["estimated_current_bounds_a"]
v_left_low, v_left_high = left["load_v_bounds"]
v_right_low, v_right_high = right["load_v_bounds"]
delta_i_low = i_right_low - i_left_high
delta_v_low = v_right_low - v_left_high
if delta_i_low <= 0 or delta_v_low <= 0:
return {"status": "positive slope unresolved", "estimate_ohms": None}
delta_i = right["estimated_current_a"] - left["estimated_current_a"]
delta_v = right["load_v"] - left["load_v"]
return {
"status": "positive slope resolved",
"estimate_ohms": delta_v / delta_i,
"bounds_ohms": [
delta_v_low / (i_right_high - i_left_low),
(v_right_high - v_left_low) / delta_i_low,
],
}
def compare_endpoints(first, last):
first_low, first_high = first["operating_resistance_bounds_ohms"]
last_low, last_high = last["operating_resistance_bounds_ohms"]
if last_low > first_high:
return "increase resolved"
if last_high < first_low:
return "decrease resolved"
return "change unresolved within supplied bounds"
def analyze(stream, shunt_ohms=10.0, shunt_error_percent=1.0):
shunt_ohms = bounded(shunt_ohms, 9.90, 10.10, "shunt resistance in ohms")
error = bounded(shunt_error_percent, 0.05, 2.0, "shunt error percent") / 100
observations = parse_worksheet(stream, shunt_ohms, error)
devices = {}
for device in DEVICES:
points = {point: observations[device, point] for point in RAILS}
devices[device] = {
"points": points,
"operating_resistance_change": compare_endpoints(points["small"], points["high"]),
"middle_to_high_segment_slope": segment_slope(points["middle"], points["high"]),
}
return {
"assumed_shunt_ohms": shunt_ohms,
"shunt_error_percent": shunt_error_percent,
"devices": devices,
}
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("worksheet", type=Path)
parser.add_argument("--shunt-ohms", type=float, default=10.0)
parser.add_argument("--shunt-error-percent", type=float, default=1.0)
args = parser.parse_args()
try:
with args.worksheet.open(encoding="utf-8-sig", newline="") as stream:
result = analyze(stream, args.shunt_ohms, args.shunt_error_percent)
except (OSError, ValueError, csv.Error) as error:
print(f"Worksheet error: {error}", file=sys.stderr)
return 2
print(json.dumps(result, indent=2, allow_nan=False))
return 0
if __name__ == "__main__":
sys.exit(main())
Suppose a lamp and a resistor each have 50 Ω at one measured operating point. Do they therefore draw the same current at another voltage?
Take another settled voltage and current pair for each. A fixed resistor stays close to the original ratio under comparable conditions. The filament heats differently as power changes, so its ratio can move. A separate pair also lets you compare the slope over that interval.
The four-wire resistance experiment shows how moving the sense points changes what a low resistance reading includes. The analyzer's tests use synthetic readings. Enter your own readings in the blank sheet after running the fixture.