The supplied Python program evaluates the primary nominal equation, passive-component corners, a simplified cycle and finite-window counts. It uses exact exponential RC segments in that simplified model: during the packet CL charges toward I×RL; afterward it decays through RL until Vx returns to the assumed settled input threshold. This model’s average Vx is slightly above VIN, so its frequency differs from the simple VIN/RL approximation. That discrepancy illustrates the model boundary; it is not a correction calibrated for a real LM331.
The passive corners enumerate 16 combinations of RS/RL/RT at ±1% and CT at ±5%. At 1 V they span approximately 910.492–1068.563 Hz. This excludes the IC’s own reference/gain/offset and every physical uncertainty, so do not label it a total accuracy bound. The code rejects non-finite values and restricts component, voltage, time and count domains before arithmetic.
Complete lm331_window.py
"""HOST-ONLY LM331 nominal charge arithmetic and finite counting model.
TI SNOSBI2C Figure14 external network adapted to 5.0V/0.2..2.0V.
Not SPICE, not silicon/bench validation, no GPIO or target firmware.
"""
import argparse
import itertools
import json
import math
RS, RL, RT, CT, CL = 14000.0, 100000.0, 6800.0, 1e-8, 1e-6
def number(x, low, high, name):
if type(x) not in (int, float) or not math.isfinite(x) or not low <= x <= high:
raise ValueError(name)
return float(x)
def nominal(vin, rs=RS, rl=RL, rt=RT, ct=CT):
vin = number(vin, .2, 2, 'VIN_0_2_TO_2V')
rs = number(rs, 12000, 17000, 'RS')
rl = number(rl, 90000, 110000, 'RL')
rt = number(rt, 6000, 7500, 'RT')
ct = number(ct, 8e-9, 12e-9, 'CT')
current = 1.90 / rs
pulse = 1.1 * rt * ct
charge = current * pulse
frequency = vin / (rl * charge)
duty = frequency * pulse
if not all(math.isfinite(x) and x > 0 for x in (current, pulse, charge, frequency, duty)) or duty >= .25:
raise ValueError('MODEL_RANGE')
return {'vin_V': vin, 'reference_current_A_nominal': current,
'pulse_s_nominal': pulse, 'charge_C_nominal': charge,
'frequency_Hz_nominal': frequency, 'duty_nominal': duty,
'scale_Hz_per_V_nominal': frequency / vin}
def count_periodic(frequency, window, phase=0):
"""Ideal periodic edges in (0,T], phase = fractional cycle at t=0."""
f = number(frequency, .01, 100000, 'FREQUENCY')
t = number(window, .001, 60, 'WINDOW')
phase = number(phase, 0, .999999999, 'PHASE')
return math.floor(f * t + phase) - math.floor(phase)
def infer_count(count, window, vin_for_scale=1):
if type(count) is not int or not 0 <= count <= 10000000:
raise ValueError('INTEGER_COUNT')
window = number(window, .001, 60, 'WINDOW')
k = nominal(vin_for_scale)['scale_Hz_per_V_nominal']
return {'observed_count': count, 'window_s': window,
'count_rate_Hz': count / window,
'voltage_V_from_nominal_scale': count / window / k,
'one_count_Hz': 1 / window,
'one_count_V_nominal': 1 / window / k,
'status': 'NO_EDGES_NOT_PROOF_OF_ZERO' if count == 0 else 'COUNT_ONLY_NOT_CALIBRATED_VOLTAGE'}
def passive_corners(vin):
values = [nominal(vin, RS * s, RL * l, RT * t, CT * c)['frequency_Hz_nominal']
for s, l, t, c in itertools.product((.99, 1.01), (.99, 1.01), (.99, 1.01), (.95, 1.05))]
return {'minimum_Hz': min(values), 'maximum_Hz': max(values),
'scope': 'Passive RS/RL/RT1percent and CT5percent only; excludes IC gain/offset, temperature, leakage, calibration and timing instrumentation.'}
def ideal_cycle(vin):
"""Exact RC segments of a simplified ideal source/CL/RL model.
Excludes physical R47 hysteresis branch, comparator/timer delays, reference
tolerance, source compliance, capacitor parasitics, startup and input filter.
Starts at an assumed settled trigger threshold Vx=Vin.
"""
n = nominal(vin)
current, on = n['reference_current_A_nominal'], n['pulse_s_nominal']
tau, asymptote = RL * CL, current * RL
peak = asymptote + (vin - asymptote) * math.exp(-on / tau)
off = tau * math.log(peak / vin)
period = on + off
return {'on_s': on, 'off_s': off, 'period_s': period,
'frequency_Hz_ideal_RC': 1 / period, 'peak_V_ideal': peak,
'ripple_V_ideal': peak - vin, 'threshold_V': vin}
def trace(vin=1, duration=.003, step=.000005):
duration = number(duration, .0001, .02, 'DURATION')
step = number(step, .000001, .00002, 'STEP')
if duration / step > 20000:
raise ValueError('TRACE_LIMIT')
n, cycle = nominal(vin), ideal_cycle(vin)
rows = []
for i in range(int(duration / step) + 1):
t = i * step
phase = t % cycle['period_s']
active = phase < cycle['on_s']
if active:
end = n['reference_current_A_nominal'] * RL
vx = end + (vin - end) * math.exp(-phase / (RL * CL))
else:
vx = cycle['peak_V_ideal'] * math.exp(-(phase - cycle['on_s']) / (RL * CL))
rows.append({'t_s': t, 'vx_V': vx, 'pump_A': n['reference_current_A_nominal'] if active else 0,
'FOUT_model': 'LOW' if active else 'RELEASED_HIGH_Z'})
return rows
def report(vin=1, window=.1, count=None):
n = nominal(vin)
if count is None:
count = count_periodic(n['frequency_Hz_nominal'], window)
origin = 'CONSTRUCTED_PERIODIC_COUNT_NOT_MEASURED'
else:
origin = 'USER_ENTERED_COUNT_NOT_HARDWARE_VALIDATED'
return {'nominal': n, 'passive_corners': passive_corners(vin),
'ideal_cycle': ideal_cycle(vin), 'count': infer_count(count, window),
'count_origin': origin, 'hardware_tested': False, 'target_executed': False}
if __name__ == '__main__':
p = argparse.ArgumentParser(description=__doc__)
p.add_argument('--vin', type=float, default=1)
p.add_argument('--window', type=float, default=.1)
p.add_argument('--count', type=int, default=None)
a = p.parse_args()
print(json.dumps(report(a.vin, a.window, a.count), indent=2))
