def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
timer = Stopwatch()
measurements = []
# for _ in range(config.repeat):
while 1:
f = mcu.counter.read(config.gate_time)
measurements.append(dict(
t=timer.read(),
frequency=nominal_value(f),
))
if timer.last > config.interval:
break
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=measurements,
gate_time=config.gate_time,
)
return data
def measure(config, stop_condition=None):
mcu = ArduinoTree()
# if config.reset:
# mcu.soft_reset()
vcc = mcu.vcc.read()
pin = mcu.pin.get(config.pin)
interval = config.interval
measurements = []
timer = Stopwatch()
while 1:
measurements.append(dict(
t=timer.read(),
A=pin.read_analog_value(),
))
if timer.last > interval:
break
if stop_condition:
if stop_condition(timer):
break
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=measurements,
)
return data
def measure(config, stop_condition=None):
mcu = ArduinoTree()
# if config.reset:
# mcu.soft_reset()
vcc = mcu.vcc.read()
pin = mcu.pin.get(config.pin)
interval = config.interval
measurements = []
timer = Stopwatch()
while 1:
measurements.append(dict(
t=timer.read(),
A=pin.read_analog_value(),
))
if timer.last > interval:
break
if stop_condition:
if stop_condition(timer):
break
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=measurements,
)
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
timer = Stopwatch()
measurements = []
# for _ in range(config.repeat):
while 1:
f = mcu.counter.read(config.gate_time)
measurements.append(dict(
t=timer.read(),
frequency=nominal_value(f),
))
if timer.last > config.interval:
break
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=measurements,
gate_time=config.gate_time,
)
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
p_pwm = mcu.pin.get(config.pin_pwm)
pwm_manager = PwmManager(config.pwm, [p_pwm])
p_in = mcu.pin.get(config.pin_in)
timer = Stopwatch()
# max freq
# pwm.divisor = config.pwm.divisor
# print 'freq=%s' % pwm.frequency
def meas():
def loop(measurements, pwm_value):
measurements.append(dict(
t=timer.read(),
pwm_value=pwm_value,
Ain=p_in.read_analog_value(),
))
measurements = pwm_manager.measure(loop)
return measurements
# pwm.write_value(config.pwm.start)
# time.sleep(1)
# measurements = []
# tstart = time.time()
# for i in range(config.pwm.start, config.pwm.end + 1):
# pwm.write_value(i)
# time.sleep(config.wait)
# A = p_in.read_analog_value()
# measurements.append(dict(
# t=timer.read(),
# pwm_value=i,
# A=A,
# ))
# return measurements
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=meas(),
frequency=p_pwm.pwm.frequency,
)
p_pwm.reset()
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
p_pwm = mcu.pin.get(config.pin_pwm)
pwm_manager = PwmManager(config.pwm, [p_pwm])
# pwm = p_pwm.pwm
p_amp = mcu.pin.get(config.pin_amp_out)
p_out_an = mcu.pin.get(config.pin_out_an)
p_out_dig = mcu.pin.get(config.pin_out_dig)
timer = Stopwatch()
# pwm.divisor = config.pwm.divisor
def meas(dig_out):
p_out_dig.write_digital_value(dig_out)
def loop(measurements, pwm_value):
measurements.append(
dict(
t=timer.read(),
pwm_value=pwm_value,
Aamp=p_amp.read_analog_value(),
Aout=p_out_an.read_analog_value(),
Dout=dig_out,
))
measurements = pwm_manager.measure(loop)
return measurements
measurements = []
p_out_dig.write_mode(OUTPUT)
measurements += meas(1)
measurements += meas(0)
p_out_dig.reset()
p_pwm.reset()
data = dict(
vcc=vcc,
model=avr_name(mcu),
frequency=p_pwm.pwm.frequency,
measurements=measurements,
)
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
p_enable_input = mcu.pin.get(config.pin_enable_input)
timer = Stopwatch()
def measure1(enable_input, repeat):
if enable_input:
p_enable_input.write_mode(OUTPUT)
p_enable_input.write_digital_value(1)
else:
p_enable_input.reset()
measurements = []
for _ in range(repeat):
f = mcu.counter.read(config.gate_time)
measurements.append(
dict(
t=timer.read(),
frequency=nominal_value(f),
enable_input=int(enable_input),
))
return measurements
measurements = []
# measurements += measure1(False, config.repeat_disable_input)
# measurements += measure1(True, config.repeat_enable_input)
measurements += measure1(False, 8)
measurements += measure1(True, 8)
measurements += measure1(False, 8)
measurements += measure1(True, 15)
measurements += measure1(False, 8)
measurements += measure1(True, 30)
p_enable_input.reset()
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=measurements,
gate_time=config.gate_time,
)
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
p_pwm = mcu.pin.get(config.pin_pwm)
pwm_manager = PwmManager(config.pwm, [p_pwm])
# pwm = p_pwm.pwm
p_amp = mcu.pin.get(config.pin_amp_out)
p_out_an = mcu.pin.get(config.pin_out_an)
p_out_dig = mcu.pin.get(config.pin_out_dig)
timer = Stopwatch()
# pwm.divisor = config.pwm.divisor
def meas(dig_out):
p_out_dig.write_digital_value(dig_out)
def loop(measurements, pwm_value):
measurements.append(dict(
t=timer.read(),
pwm_value=pwm_value,
Aamp=p_amp.read_analog_value(),
Aout=p_out_an.read_analog_value(),
Dout=dig_out,
))
measurements = pwm_manager.measure(loop)
return measurements
measurements = []
p_out_dig.write_mode(OUTPUT)
measurements += meas(1)
measurements += meas(0)
p_out_dig.reset()
p_pwm.reset()
data = dict(
vcc=vcc,
model=avr_name(mcu),
frequency=p_pwm.pwm.frequency,
measurements=measurements,
)
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
p_enable_input = mcu.pin.get(config.pin_enable_input)
timer = Stopwatch()
def measure1(enable_input, repeat):
if enable_input:
p_enable_input.write_mode(OUTPUT)
p_enable_input.write_digital_value(1)
else:
p_enable_input.reset()
measurements = []
for _ in range(repeat):
f = mcu.counter.read(config.gate_time)
measurements.append(dict(
t=timer.read(),
frequency=nominal_value(f),
enable_input=int(enable_input),
))
return measurements
measurements = []
# measurements += measure1(False, config.repeat_disable_input)
# measurements += measure1(True, config.repeat_enable_input)
measurements += measure1(False, 8)
measurements += measure1(True, 8)
measurements += measure1(False, 8)
measurements += measure1(True, 15)
measurements += measure1(False, 8)
measurements += measure1(True, 30)
p_enable_input.reset()
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=measurements,
gate_time=config.gate_time,
)
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
p_pwm = mcu.pin.get(config.pin_pwm)
pwm_manager = PwmManager(config.pwm, [p_pwm])
p_amp = mcu.pin.get(config.pin_amp_out)
p_in = mcu.pin.get(config.pin_x_in)
p_out = mcu.pin.get(config.pin_x_out)
p_rail = mcu.pin.get(config.pin_rail)
timer = Stopwatch()
def meas(rail):
p_rail.write_mode(OUTPUT)
p_rail.write_digital_value(rail)
def loop(measurements, pwm_value):
measurements.append(
dict(
t=timer.read(),
pwm_value=pwm_value,
Aamp=p_amp.read_analog_value(),
Ain=p_in.read_analog_value(),
Aout=p_out.read_analog_value(),
rail=rail,
))
measurements = pwm_manager.measure(loop)
p_rail.reset()
return measurements
measurements = []
measurements += meas(1)
measurements += meas(0)
p_pwm.reset()
data = dict(
vcc=vcc,
model=avr_name(mcu),
pwm_frequency=p_pwm.pwm.frequency,
measurements=measurements,
)
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
p_pwm = mcu.pin.get(config.pin_pwm)
pwm_manager = PwmManager(config.pwm, [p_pwm])
p_in = mcu.pin.get(config.pin_in)
timer = Stopwatch()
# max freq
# pwm.divisor = config.pwm.divisor
# print 'freq=%s' % pwm.frequency
def meas():
def loop(measurements, pwm_value):
measurements.append(dict(t=timer.read(), pwm_value=pwm_value, Ain=p_in.read_analog_value()))
measurements = pwm_manager.measure(loop)
return measurements
# pwm.write_value(config.pwm.start)
# time.sleep(1)
# measurements = []
# tstart = time.time()
# for i in range(config.pwm.start, config.pwm.end + 1):
# pwm.write_value(i)
# time.sleep(config.wait)
# A = p_in.read_analog_value()
# measurements.append(dict(
# t=timer.read(),
# pwm_value=i,
# A=A,
# ))
# return measurements
data = dict(vcc=vcc, model=avr_name(mcu), measurements=meas(), frequency=p_pwm.pwm.frequency)
p_pwm.reset()
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
p_pwm = mcu.pin.get(config.pin_pwm)
pwm_manager = PwmManager(config.pwm, [p_pwm])
p_amp = mcu.pin.get(config.pin_amp_out)
p_in = mcu.pin.get(config.pin_x_in)
p_out = mcu.pin.get(config.pin_x_out)
p_rail = mcu.pin.get(config.pin_rail)
timer = Stopwatch()
def meas(rail):
p_rail.write_mode(OUTPUT)
p_rail.write_digital_value(rail)
def loop(measurements, pwm_value):
measurements.append(dict(
t=timer.read(),
pwm_value=pwm_value,
Aamp=p_amp.read_analog_value(),
Ain=p_in.read_analog_value(),
Aout=p_out.read_analog_value(),
rail=rail,
))
measurements = pwm_manager.measure(loop)
p_rail.reset()
return measurements
measurements = []
measurements += meas(1)
measurements += meas(0)
p_pwm.reset()
data = dict(
vcc=vcc,
model=avr_name(mcu),
pwm_frequency=p_pwm.pwm.frequency,
measurements=measurements,
)
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
p_pwm = mcu.pin.get(config.pin_pwm)
pwm_manager = PwmManager(config.pwm, [p_pwm])
# p_in = mcu.pin.get(config.pin_x_in)
# p_out = mcu.pin.get(config.pin_x_out)
# p_rail = mcu.pin.get(config.pin_rail)
pin_an_in = mcu.pin.get(config.pin_an_in)
pin_dig_in = mcu.pin.get(config.pin_dig_in)
timer = Stopwatch()
def meas(reverse):
def loop(measurements, pwm_value):
measurements.append(
dict(
t=timer.read(),
pwm_value=pwm_value,
Ain=pin_an_in.read_analog_value(),
Din=pin_dig_in.read_digital_value(),
reverse=reverse,
))
measurements = pwm_manager.measure(loop, reverse=reverse)
return measurements
measurements = []
measurements += meas(0)
measurements += meas(1)
p_pwm.reset()
data = dict(
vcc=vcc,
model=avr_name(mcu),
pwm_frequency=p_pwm.pwm.frequency,
measurements=measurements,
)
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
p_pwm = mcu.pin.get(config.pin_pwm)
pwm_manager = PwmManager(config.pwm, [p_pwm])
# p_in = mcu.pin.get(config.pin_x_in)
# p_out = mcu.pin.get(config.pin_x_out)
# p_rail = mcu.pin.get(config.pin_rail)
pin_an_in = mcu.pin.get(config.pin_an_in)
pin_dig_in = mcu.pin.get(config.pin_dig_in)
timer = Stopwatch()
def meas(reverse):
def loop(measurements, pwm_value):
measurements.append(dict(
t=timer.read(),
pwm_value=pwm_value,
Ain=pin_an_in.read_analog_value(),
Din=pin_dig_in.read_digital_value(),
reverse=reverse,
))
measurements = pwm_manager.measure(loop, reverse=reverse)
return measurements
measurements = []
measurements += meas(0)
measurements += meas(1)
p_pwm.reset()
data = dict(
vcc=vcc,
model=avr_name(mcu),
pwm_frequency=p_pwm.pwm.frequency,
measurements=measurements,
)
return data
def measure(config):
mcu = ArduinoTree()
vcc = mcu.vcc.read()
p_inc = mcu.pin.get(config.pin_inc)
p_ud = mcu.pin.get(config.pin_ud)
p_cs = mcu.pin.get(config.pin_cs)
p_in = mcu.pin.get(config.pin_in)
pot = DigiPot(p_inc, p_ud, p_cs)
pot_values = range(pot.range[0], pot.range[1] + 1)
timer = Stopwatch(len(pot_values))
def meas():
measurements = []
for i in pot_values:
pot.set(i)
sleep(0.01)
Ain = p_in.read_analog_value()
measurements.append(dict(
t=timer.read(),
value=i,
Ain=Ain,
))
timer.next(measurements)
return measurements
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=meas(),
)
return data
def measure(config):
mcu = ArduinoTree()
vcc = mcu.vcc.read()
p_inc = mcu.pin.get(config.pin_inc)
p_ud = mcu.pin.get(config.pin_ud)
p_cs = mcu.pin.get(config.pin_cs)
p_in = mcu.pin.get(config.pin_in)
pot = DigiPot(p_inc, p_ud, p_cs)
pot_values = range(pot.range[0], pot.range[1] + 1)
timer = Stopwatch(len(pot_values))
def meas():
measurements = []
for i in pot_values:
pot.set(i)
sleep(0.01)
Ain = p_in.read_analog_value()
measurements.append(dict(
t=timer.read(),
value=i,
Ain=Ain,
))
timer.next(measurements)
return measurements
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=meas(),
)
return data
def measure(config):
random.seed()
mcu = ArduinoTree()
vcc = mcu.vcc.read()
p_in = mcu.pin.get(config.pin_in)
timer = Stopwatch(config.count)
measurements = []
for i in range(config.count):
measurements.append(dict(
t=timer.read(),
Ain=p_in.read_analog_value(),
))
time.sleep(random.random() * config.max_sleep)
timer.next(measurements)
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=measurements,
)
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
p_pwm = mcu.pin.get(config.pin_pwm)
pwm_manager = PwmManager(config.pwm, [p_pwm])
p_volt_in = mcu.pin.get(config.pin_volt_in)
p_current_in = mcu.pin.get(config.pin_current_in)
timer = Stopwatch()
# max freq
# pwm.divisor = config.pwm.divisor
# print 'freq=%s' % pwm.frequency
def meas():
def loop(measurements, pwm_value):
measurements.append(dict(
t=timer.read(),
pwm_value=pwm_value,
Avolt=p_volt_in.read_analog_value(),
Acurrent=p_current_in.read_analog_value(),
))
measurements = pwm_manager.measure(loop)
return measurements
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=meas(),
frequency=p_pwm.pwm.frequency,
)
p_pwm.reset()
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
timer = Stopwatch()
def measure_beta(nodeB, nodeC, nodeE, polarity):
measurements = []
pB = mcu.pin.get(nodeB.pin_middle)
pC = mcu.pin.get(nodeC.pin_middle)
pE = mcu.pin.get(nodeE.pin_middle)
elemRb = highR_elem(nodeB.toplist)
elemRc = lowR_elem(nodeC.toplist)
pRb = mcu.pin.get(elemRb.pin_rail)
pRc = mcu.pin.get(elemRc.pin_rail)
Rb = elemRb.R
Rc = elemRc.R
def read(pin):
return pin.analog_in().u_value
def delay():
time.sleep(1 / 1000.0)
pB.write_mode(INPUT)
pC.write_mode(INPUT)
pE.write_mode(OUTPUT)
pRb.write_mode(OUTPUT)
pRc.write_mode(OUTPUT)
if (polarity == 'NPN'):
pE.write_digital_value(0)
pRb.write_digital_value(1)
pRc.write_digital_value(1)
else:
pE.write_digital_value(1)
pRb.write_digital_value(0)
pRc.write_digital_value(0)
delay()
pB.read_analog_value()
pB.read_analog_value()
pB.read_analog_value()
for _ in range(config.filter_size):
measurements.append(dict(
t=timer.read(),
Ab=pB.read_analog_value(),
Rb=Rb,
Rc=Rc,
polarity=polarity,
B=nodeB.name,
C=nodeC.name,
E=nodeE.name,
))
pC.read_analog_value()
pC.read_analog_value()
pC.read_analog_value()
for _ in range(config.filter_size):
measurements.append(dict(
t=timer.read(),
Ac=pC.read_analog_value(),
Rb=Rb,
Rc=Rc,
polarity=polarity,
B=nodeB.name,
C=nodeC.name,
E=nodeE.name,
))
pB.reset()
pC.reset()
pE.reset()
pRb.reset()
pRc.reset()
return measurements
measurements = []
combinations = [(0, 1, 2), (0, 2, 1),
(1, 2, 0), (1, 0, 2),
(2, 1, 0), (2, 0, 1),
]
for k1, k2, k3 in combinations:
nodeB = config.nodes[k1]
nodeC = config.nodes[k2]
nodeE = config.nodes[k3]
measurements += measure_beta(nodeB, nodeC, nodeE, polarity='PNP')
measurements += measure_beta(nodeB, nodeC, nodeE, polarity='NPN')
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=measurements,
)
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
p_middle = mcu.pin.get(config.pin_middle)
if config.pullup:
assert INVERT
p_middle.write_pullup(config.pullup)
# p_bottom = mcu.pin.get(config.pin_bottom)
timer = Stopwatch()
def measure1(pin_rail, pin_input, R):
measurements = []
if INVERT:
Abottom = 1023
top = 0
Atop = 0
else:
Abottom = 0
top = 1
Atop = 1023
# Abottom = 0
# p_bottom.mode =
pin_rail.write_mode(OUTPUT)
# p_bottom.write_digital_value(bottom)
pin_rail.write_digital_value(top)
# first read is not stable by 1MOhm because of A/D capacitor
p_middle.read_analog_value()
p_middle.read_analog_value()
p_middle.read_analog_value()
time.sleep(0.02)
for _ in range(config.window):
Amiddle = p_middle.read_analog_value()
measurements.append(dict(
t=timer.read(),
Amiddle=Amiddle,
R=R,
))
if pin_input:
for _ in range(config.window):
Atop = pin_input.read_analog_value()
measurements.append(dict(
t=timer.read(),
R=R,
Atop=Atop,
))
else:
measurements.append(dict(
t=timer.read(),
R=R,
Atop=Atop,
))
measurements.append(dict(
t=timer.read(),
Abottom=Abottom,
R=R,
))
# p_bottom.reset()
pin_rail.reset()
return measurements
measurements = []
for d in config.toplist:
pin_rail = mcu.pin.get(d['pin_rail'])
pin_input = None
if 'pin_input' in d:
pin_input = mcu.pin.get(d['pin_input'])
R = d['R']
measurements += measure1(pin_rail, pin_input, R)
# measurements += measure1(pin_rail, pin_input,R, 1)
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=measurements,
)
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
p_middle = mcu.pin.get(config.pin_middle)
measurements = []
timer = Stopwatch()
timeout = config.charge_timeout
toplist = sorted(config.toplist, key=lambda e: e.R)
top_charge = toplist[0]
pin_charge = mcu.pin.get(top_charge.pin_rail)
def setcharge(value, limit):
measurements = []
pin_charge.write_mode(OUTPUT)
pin_charge.write_digital_value(value)
def loop_func():
a = p_middle.read_analog_value()
measurements.append(
dict(
t=timer.read(),
Amiddle=a,
R=top_charge.R,
charge=1,
# cont=1,
))
if value == 1:
if a > limit:
return False
else:
if a < limit:
return False
return True
timeout_loop(timeout, loop_func)
pin_charge.reset()
return measurements
def discharge(limit=None):
if limit is None:
limit = config.lower_limit
return setcharge(value=0, limit=limit)
def charge(limit=None):
if limit is None:
limit = config.upper_limit
return setcharge(value=1, limit=limit)
def measure1(measurements, pin_rail, pin_input, R):
def loop_func():
Amiddle = p_middle.read_analog_value()
measurements.append(
dict(
t=timer.read(),
Amiddle=Amiddle,
R=R,
charge=0,
# cont=int(tmeasure is None),
))
if Amiddle < config.lower_limit:
return False
return True
measurements += charge()
pin_rail.write_mode(OUTPUT)
pin_rail.write_digital_value(0)
# first read is not stable by 1MOhm because of A/D capacitor
p_middle.read_analog_value()
# if tmeasure:
# loop_func()
# time.sleep(tmeasure)
# loop_func()
# else:
timeout_loop(timeout, loop_func)
# pin_rail.reset()
for d in toplist:
pin_rail = mcu.pin.get(d['pin_rail'])
pin_input = mcu.pin.get(d['pin_input'])
R = d['R']
# timer3 = Stopwatch()
try:
measure1(measurements, pin_rail, pin_input, R)
except TimeOutError as e:
print e
break
finally:
# tm=timer3.read()
# tm*=0.9
# print tm
# measure1(measurements, pin_rail, pin_input, R, tm)
pin_rail.reset()
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=measurements,
)
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
p_in = mcu.pin.get(config.pin_in)
p_pwm = mcu.pin.get(config.pin_pwm)
# p_pwm2 = mcu.pin.get('D8')
# p_pwm_check = mcu.pin.get(config.pin_pwm_check)
timer = Stopwatch()
p_pwm.write_mode(OUTPUT)
# p_pwm2.write_mode(OUTPUT)
# def meas_max():
# time.sleep(1)
# p_pwm2.write_digital_value(1)
#
# time.sleep(config.settle_time)
#
# measurements = []
# for i in range(config.window):
# timer.measure()
# Apwm = p_pwm_check.read_analog_value()
# measurements.append(dict(
# t=timer.relativ(),
# # pwm_value=pwm_value,
# Apwm=Apwm,
# ))
# return measurements
pwm = p_pwm.pwm
# pwm.divisor = 1
def meas(frequency, dc=0):
if frequency == 0:
pwm.write_value(dc * 255)
else:
pwm.set_high_freq_around(frequency)
frequency = pwm.read_frequency()
# pwm_value = int(pwm_value)
# pwm.write_value(pwm_value)
# there is a slow drift when starting the measurement
# so it is better to read continuously while sleeping
sleep_and_read(config.settle_time, p_in)
# time.sleep(config.settle_time)
measurements = []
for i in range(config.window):
Ain = p_in.read_analog_value()
measurements.append(dict(
t=timer.read(),
Ain=Ain,
frequency=frequency,
dc=dc,
))
return measurements
measurements = []
measurements += meas(0, 0)
measurements += meas(0, 1)
for f in logspace(log10(config.freq.min), log10(config.freq.max), config.freq.steps):
measurements += meas(f)
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=measurements,
)
p_in.reset()
p_pwm.reset()
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
p_middle = mcu.pin.get(config.pin_middle)
measurements = []
timer = Stopwatch()
timeout = config.charge_timeout
toplist = sorted(config.toplist, key=lambda e: e.R)
top_charge = toplist[0]
pin_charge = mcu.pin.get(top_charge.pin_rail)
def setcharge(value, limit):
measurements = []
pin_charge.write_mode(OUTPUT)
pin_charge.write_digital_value(value)
def loop_func():
a = p_middle.read_analog_value()
measurements.append(dict(
t=timer.read(),
Amiddle=a,
R=top_charge.R,
charge=1,
# cont=1,
))
if value == 1:
if a > limit:
return False
else:
if a < limit:
return False
return True
timeout_loop(timeout, loop_func)
pin_charge.reset()
return measurements
def discharge(limit=None):
if limit is None:
limit = config.lower_limit
return setcharge(value=0, limit=limit)
def charge(limit=None):
if limit is None:
limit = config.upper_limit
return setcharge(value=1, limit=limit)
def measure1(measurements, pin_rail, pin_input, R):
def loop_func():
Amiddle = p_middle.read_analog_value()
measurements.append(dict(
t=timer.read(),
Amiddle=Amiddle,
R=R,
charge=0,
# cont=int(tmeasure is None),
))
if Amiddle < config.lower_limit:
return False
return True
measurements += charge()
pin_rail.write_mode(OUTPUT)
pin_rail.write_digital_value(0)
# first read is not stable by 1MOhm because of A/D capacitor
p_middle.read_analog_value()
# if tmeasure:
# loop_func()
# time.sleep(tmeasure)
# loop_func()
# else:
timeout_loop(timeout, loop_func)
# pin_rail.reset()
for d in toplist:
pin_rail = mcu.pin.get(d['pin_rail'])
pin_input = mcu.pin.get(d['pin_input'])
R = d['R']
# timer3 = Stopwatch()
try:
measure1(measurements, pin_rail, pin_input, R)
except TimeOutError as e:
print e
break
finally:
# tm=timer3.read()
# tm*=0.9
# print tm
# measure1(measurements, pin_rail, pin_input, R, tm)
pin_rail.reset()
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=measurements,
)
return data
def measure(config):
A = config.R2 / config.R1
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
timer = Stopwatch()
for d in config.loads:
mcu.pin.get(d.pin_load).reset()
p_pwm_plus = mcu.pin.get(config.pin_pwm_plus)
p_pwm_minus = mcu.pin.get(config.pin_pwm_minus)
pwm_manager = PwmManager(config.pwm, [p_pwm_plus, p_pwm_minus])
p_in_plus = mcu.pin.get(config.pin_in_plus)
p_in_minus = mcu.pin.get(config.pin_in_minus)
p_out = mcu.pin.get(config.pin_out)
# def noise_filter(fread):
# filter_size = 5
# return filters.median_filter(fread, filter_size)
def meas(R, pwm_values, phase=None):
def loop(measurements, pwm_index_plus, pwm_index_minus):
measurements.append(
dict(
t=timer.read(),
pwm_index_plus=pwm_index_plus,
pwm_index_minus=pwm_index_minus,
Aplus=p_in_plus.read_analog_value(),
Aminus=p_in_minus.read_analog_value(),
Aout=p_out.read_analog_value(),
Rload=R,
phase=phase,
))
measurements = pwm_manager.measure(loop, pwm_values)
return measurements
def meas_multi():
measurements = []
# unity gain test: Vplus=Vminus
# ls = [(x, x) for x in fullrange(config.pwm.start, config.pwm.end)]
measurements += meas(None, pwm_values=None, phase='unity_gain')
# return measurements
# determine good range for both input and ouput
# d2 = data.copy()
# d2['measurements'] = measurements
low, high = calculate_good_interval(config, measurements, limit=10)
# print low, high
Alow, Ahigh = low + 0.25 * (high - low), low + 0.75 * (high - low)
low, high = map(an2pwm, [Alow, Ahigh])
# input_swing test
# output is always in good range if input is allowed
avg = (low + high) / 2
ls = [(math.ceil(x + (avg - x) / (A + 1)), x)
for x in pwm_manager.range]
measurements += meas(None, pwm_values=ls, phase='input_range')
# output_swing test
# input is always in good range
loads = [(d.pin_load, d.Rload) for d in config.loads]
for nr, R in [(None, None)] + loads:
if nr is not None:
mcu.pin.get(nr).write_mode(OUTPUT)
mcu.pin.get(nr).write_digital_value(0)
# Vminus is fixed in upper range
Aplus = Circuit(A, Vminus=Ahigh, Vout=-20).Vplus
ls = [(x, high) for x in fullrange(an2pwm(Aplus), high)]
measurements += meas(R, pwm_values=ls, phase='output_swing')
# to increase resolution
for i in range(9):
ls = [(x, high - i) for x in fullrange(an2pwm(Aplus), high)]
measurements += meas(R, pwm_values=ls, phase='output_swing')
# Vminus is fixed in lower range
Aplus = Circuit(A, Vminus=Alow, Vout=1040).Vplus
ls = [(x, low) for x in fullrange(low, an2pwm(Aplus))]
# to increase resolution
for i in range(9):
ls = [(x, low + i) for x in fullrange(low, an2pwm(Aplus))]
measurements += meas(R, pwm_values=ls, phase='output_swing')
if nr is not None:
mcu.pin.get(nr).reset()
return measurements
data = Bunch(
vcc=vcc,
model=avr_name(mcu),
pwm_plus_frequency=p_pwm_plus.pwm.frequency,
pwm_minus_frequency=p_pwm_minus.pwm.frequency,
measurements=meas_multi(),
)
p_pwm_plus.reset()
p_pwm_minus.reset()
return data
def measure(config):
A = config.R2 / config.R1
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
timer = Stopwatch()
for d in config.loads:
mcu.pin.get(d.pin_load).reset()
p_pwm_plus = mcu.pin.get(config.pin_pwm_plus)
p_pwm_minus = mcu.pin.get(config.pin_pwm_minus)
pwm_manager = PwmManager(config.pwm, [p_pwm_plus, p_pwm_minus])
p_in_plus = mcu.pin.get(config.pin_in_plus)
p_in_minus = mcu.pin.get(config.pin_in_minus)
p_out = mcu.pin.get(config.pin_out)
# def noise_filter(fread):
# filter_size = 5
# return filters.median_filter(fread, filter_size)
def meas(R, pwm_values, phase=None):
def loop(measurements, pwm_index_plus, pwm_index_minus):
measurements.append(dict(
t=timer.read(),
pwm_index_plus=pwm_index_plus,
pwm_index_minus=pwm_index_minus,
Aplus=p_in_plus.read_analog_value(),
Aminus=p_in_minus.read_analog_value(),
Aout=p_out.read_analog_value(),
Rload=R,
phase=phase,
))
measurements = pwm_manager.measure(loop, pwm_values)
return measurements
def meas_multi():
measurements = []
# unity gain test: Vplus=Vminus
# ls = [(x, x) for x in fullrange(config.pwm.start, config.pwm.end)]
measurements += meas(None, pwm_values=None, phase='unity_gain')
# return measurements
# determine good range for both input and ouput
# d2 = data.copy()
# d2['measurements'] = measurements
low, high = calculate_good_interval(config, measurements, limit=10)
# print low, high
Alow, Ahigh = low + 0.25 * (high - low), low + 0.75 * (high - low)
low, high = map(an2pwm, [Alow, Ahigh])
# input_swing test
# output is always in good range if input is allowed
avg = (low + high) / 2
ls = [(
math.ceil(x + (avg - x) / (A + 1)), x) for x in pwm_manager.range]
measurements += meas(None, pwm_values=ls, phase='input_range')
# output_swing test
# input is always in good range
loads = [(d.pin_load, d.Rload) for d in config.loads]
for nr, R in [(None, None)] + loads:
if nr is not None:
mcu.pin.get(nr).write_mode(OUTPUT)
mcu.pin.get(nr).write_digital_value(0)
# Vminus is fixed in upper range
Aplus = Circuit(A, Vminus=Ahigh, Vout= -20).Vplus
ls = [(x, high) for x in fullrange(an2pwm(Aplus), high)]
measurements += meas(R, pwm_values=ls, phase='output_swing')
# to increase resolution
for i in range(9):
ls = [(x, high - i) for x in fullrange(an2pwm(Aplus), high)]
measurements += meas(R, pwm_values=ls, phase='output_swing')
# Vminus is fixed in lower range
Aplus = Circuit(A, Vminus=Alow, Vout=1040).Vplus
ls = [(x, low) for x in fullrange(low, an2pwm(Aplus))]
# to increase resolution
for i in range(9):
ls = [(x, low + i) for x in fullrange(low, an2pwm(Aplus))]
measurements += meas(R, pwm_values=ls, phase='output_swing')
if nr is not None:
mcu.pin.get(nr).reset()
return measurements
data = Bunch(
vcc=vcc,
model=avr_name(mcu),
pwm_plus_frequency=p_pwm_plus.pwm.frequency,
pwm_minus_frequency=p_pwm_minus.pwm.frequency,
measurements=meas_multi(),
)
p_pwm_plus.reset()
p_pwm_minus.reset()
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
timer = Stopwatch()
def measure_beta(nodeB, nodeC, nodeE, polarity):
measurements = []
pB = mcu.pin.get(nodeB.pin_middle)
pC = mcu.pin.get(nodeC.pin_middle)
pE = mcu.pin.get(nodeE.pin_middle)
elemRb = highR_elem(nodeB.toplist)
elemRc = lowR_elem(nodeC.toplist)
pRb = mcu.pin.get(elemRb.pin_rail)
pRc = mcu.pin.get(elemRc.pin_rail)
Rb = elemRb.R
Rc = elemRc.R
def read(pin):
return pin.analog_in().u_value
def delay():
time.sleep(1 / 1000.0)
pB.write_mode(INPUT)
pC.write_mode(INPUT)
pE.write_mode(OUTPUT)
pRb.write_mode(OUTPUT)
pRc.write_mode(OUTPUT)
if (polarity == 'NPN'):
pE.write_digital_value(0)
pRb.write_digital_value(1)
pRc.write_digital_value(1)
else:
pE.write_digital_value(1)
pRb.write_digital_value(0)
pRc.write_digital_value(0)
delay()
pB.read_analog_value()
pB.read_analog_value()
pB.read_analog_value()
for _ in range(config.filter_size):
measurements.append(
dict(
t=timer.read(),
Ab=pB.read_analog_value(),
Rb=Rb,
Rc=Rc,
polarity=polarity,
B=nodeB.name,
C=nodeC.name,
E=nodeE.name,
))
pC.read_analog_value()
pC.read_analog_value()
pC.read_analog_value()
for _ in range(config.filter_size):
measurements.append(
dict(
t=timer.read(),
Ac=pC.read_analog_value(),
Rb=Rb,
Rc=Rc,
polarity=polarity,
B=nodeB.name,
C=nodeC.name,
E=nodeE.name,
))
pB.reset()
pC.reset()
pE.reset()
pRb.reset()
pRc.reset()
return measurements
measurements = []
combinations = [
(0, 1, 2),
(0, 2, 1),
(1, 2, 0),
(1, 0, 2),
(2, 1, 0),
(2, 0, 1),
]
for k1, k2, k3 in combinations:
nodeB = config.nodes[k1]
nodeC = config.nodes[k2]
nodeE = config.nodes[k3]
measurements += measure_beta(nodeB, nodeC, nodeE, polarity='PNP')
measurements += measure_beta(nodeB, nodeC, nodeE, polarity='NPN')
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=measurements,
)
return data
def measure(config):
mcu = ArduinoTree()
# mcu.soft_reset()
vcc = mcu.vcc.read()
p_middle = mcu.pin.get(config.pin_middle)
if config.pullup:
assert INVERT
p_middle.write_pullup(config.pullup)
# p_bottom = mcu.pin.get(config.pin_bottom)
timer = Stopwatch()
def measure1(pin_rail, pin_input, R):
measurements = []
if INVERT:
Abottom = 1023
top = 0
Atop = 0
else:
Abottom = 0
top = 1
Atop = 1023
# Abottom = 0
# p_bottom.mode =
pin_rail.write_mode(OUTPUT)
# p_bottom.write_digital_value(bottom)
pin_rail.write_digital_value(top)
# first read is not stable by 1MOhm because of A/D capacitor
p_middle.read_analog_value()
p_middle.read_analog_value()
p_middle.read_analog_value()
time.sleep(0.02)
for _ in range(config.window):
Amiddle = p_middle.read_analog_value()
measurements.append(dict(
t=timer.read(),
Amiddle=Amiddle,
R=R,
))
if pin_input:
for _ in range(config.window):
Atop = pin_input.read_analog_value()
measurements.append(dict(
t=timer.read(),
R=R,
Atop=Atop,
))
else:
measurements.append(dict(
t=timer.read(),
R=R,
Atop=Atop,
))
measurements.append(dict(
t=timer.read(),
Abottom=Abottom,
R=R,
))
# p_bottom.reset()
pin_rail.reset()
return measurements
measurements = []
for d in config.toplist:
pin_rail = mcu.pin.get(d['pin_rail'])
pin_input = None
if 'pin_input' in d:
pin_input = mcu.pin.get(d['pin_input'])
R = d['R']
measurements += measure1(pin_rail, pin_input, R)
# measurements += measure1(pin_rail, pin_input,R, 1)
data = dict(
vcc=vcc,
model=avr_name(mcu),
measurements=measurements,
)
return data
