def run(self):
args = self.args
fname = getDateTimeFilename()
output_csv = os.path.join(str(args.output_dir), fname + u".csv")
logger = logging.getLogger(u'myLogger')
logger.debug(u' In iv_measurement.py:')
try:
keith6517B = keithley.Keithley6517B(args.devname_kei6517b)
logger.info(
u" Voltage source device introduced itself as {}".format(
keith6517B.identify()))
if not args.devname_kei6485 is None and args.guardring:
keith6485 = keithley.Keithley6485(args.devname_kei6485)
logger.info(
u" Guard ring device introduced itself as {}".format(
keith6485.identify()))
else:
keith6485 = None
logger.info(u" Running without guard ring measurement")
except VisaIOError:
errormsg = u"Could not open devices."
self.error_signal.emit(errormsg)
logger.error(errormsg)
self.finished.emit(os.path.join(str(args.output_dir), fname))
return
try:
logger.info(u"Starting measurement")
mode = 'w'
if sys.version_info.major < 3:
mode += 'b'
with open(output_csv, mode) as f:
if not keith6485 is None:
header = OrderedDict([('kei6517b_srcvoltage', None),
('kei6517b_current', None),
('kei6485_current', None)])
else:
header = OrderedDict([('kei6517b_current', None),
('kei6517b_srcvoltage', None)])
writer = csv.DictWriter(f,
fieldnames=header,
extrasaction=u"ignore")
writer.writeheader()
for voltage in keith6517B.voltage_series(
args.start, args.end, args.step):
sleep(args.sleep)
if self._exiting:
break
line = keith6517B.get_reading()
meas = keithley.parse_iv(line, u"kei6517b")
if (not u"kei6517b_srcvoltage" in meas
or not u"kei6517b_current" in meas
or meas[u"kei6517b_srcvoltage"] is None
or meas[u"kei6517b_current"] is None):
raise IOError(
u"Got invalid response from Keithley 6517B")
if self._exiting:
break
if not keith6485 is None:
gr_line = keith6485.get_reading()
meas.update(keithley.parse_iv(gr_line, u"kei6485"))
if (not u"kei6485_current" in meas
or meas[u"kei6485_current"] is None):
raise IOError(
u"Got invalid response from Keithley 6485")
print(
u"VSrc = {: 10.4g} V; I = {: 10.4g} A; IGr = {: 10.4g} A"
.format(meas[u"kei6517b_srcvoltage"],
meas[u"kei6517b_current"],
meas[u"kei6485_current"]))
else:
meas[u"kei6485_current"] = 0
print(u"VSrc = {: 10.4g} V; I = {: 10.4g} A".format(
meas[u"kei6517b_srcvoltage"],
meas[u"kei6517b_current"]))
if (abs(meas[u"kei6517b_current"]) >= args.compcurrent or
abs(meas[u"kei6485_current"]) >= args.compcurrent):
self.error_signal.emit(u"Compliance current reached")
print(u"Compliance current reached")
#Instant turn off
keith6517B.set_output_state(False)
self._exiting = True
writer.writerow(meas)
if args.guardring:
self.measurement_ready.emit(
(meas[u"kei6517b_srcvoltage"],
meas[u"kei6517b_current"],
meas[u"kei6485_current"]))
else:
self.measurement_ready.emit(
(meas[u"kei6517b_srcvoltage"],
meas[u"kei6517b_current"]))
if self._exiting:
break
except IOError as e:
errormsg = u"Error: {}".format(e)
self.error_signal.emit(errormsg)
logger.error(errormsg)
except (VisaIOError, InvalidBinaryFormat, ValueError):
errormsg = u"Error during communication with devices."
self.error_signal.emit(errormsg)
logger.error(errormsg)
finally:
logger.info(u"Stopping measurement")
try:
keith6517B.stop_measurement()
except (VisaIOError, InvalidBinaryFormat, ValueError):
logger.error(u"Error during stopping. Trying turn off output")
keith6517B.set_output_state(False)
self.finished.emit(os.path.join(str(args.output_dir), fname))
def run(self):
args = self.args
fname = getDateTimeFilename()
output_csv = os.path.join(str(args.output_dir), fname + u".csv")
logger = logging.getLogger(
u'probestation.iv_measurement.IvMeasurementThread')
logger.debug(u" In iv_measurement.py:")
try:
if args.devname_ardenv:
if not self._init_envsensor():
errormsg = u"Could not open environment sensor device."
self.error_signal.emit(errormsg)
logger.error(errormsg)
self.finished.emit(
os.path.join(str(args.output_dir), fname))
input_hv = keithley.KeithleyMeter(args.devname_hv,
args.serialenable)
if input_hv.identify().startswith(
u"KEITHLEY INSTRUMENTS INC.,MODEL 6517B"):
keith_hv = keithley.Keithley6517B(args.devname_hv,
args.serialenable)
elif input_hv.identify().startswith(
u"KEITHLEY INSTRUMENTS INC.,MODEL 2410"):
keith_hv = keithley.Keithley2410(args.devname_hv,
args.serialenable)
else:
errormsg = u"Could not open devices."
self.error_signal.emit(errormsg)
logger.error(errormsg)
self.finished.emit(os.path.join(str(args.output_dir), fname))
return
logger.info(
u" Voltage source device introduced itself as {}".format(
keith_hv.identify()))
if not args.devname_kei6485 is None and args.guardring:
keith6485 = keithley.Keithley6485(args.devname_kei6485,
args.serialenable)
logger.info(
u" Guard ring device introduced itself as {}".format(
keith6485.identify()))
else:
keith6485 = None
logger.info(u" Running without guard ring measurement")
except VisaIOError:
errormsg = u"Could not open devices."
self.error_signal.emit(errormsg)
logger.error(errormsg)
self.finished.emit(os.path.join(str(args.output_dir), fname))
return
try:
logger.info(u"Starting measurement")
mode = 'w'
if sys.version_info.major < 3:
mode += 'b'
keith_hv.set_compliance(args.compcurrent)
with open(output_csv, mode) as f:
if not keith6485 is None:
header = OrderedDict([('keihv_srcvoltage', None),
('keihv_current', None),
('kei6485_current', None)])
else:
header = OrderedDict([('keihv_srcvoltage', None),
('keihv_current', None)])
if args.devname_ardenv:
header.update({
'envsensor1_temperature': None,
'envsensor1_dewpoint': None,
'envsensor2_temperature': None,
'envsensor2_dewpoint': None
})
writer = csv.DictWriter(f,
fieldnames=header,
extrasaction=u"ignore")
writer.writeheader()
for voltage in keith_hv.voltage_series(args.start, args.end,
args.step):
sleep(args.sleep)
if self._exiting:
break
line = keith_hv.get_reading()
meas = keith_hv.parse_iv(line, u"keihv")
if args.devname_ardenv:
env = self._measure_environment()
meas.update(env)
if (not u"keihv_srcvoltage" in meas
or not u"keihv_current" in meas
or meas[u"keihv_srcvoltage"] is None
or meas[u"keihv_current"] is None):
raise IOError(
u"Got invalid response from Keithley 6517B")
if self._exiting:
break
if not keith6485 is None:
gr_line = keith6485.get_reading()
meas.update(keith6485.parse_iv(gr_line, u"kei6485"))
if (not u"kei6485_current" in meas
or meas[u"kei6485_current"] is None):
raise IOError(
u"Got invalid response from Keithley 6485")
print(
u"VSrc = {: 10.4g} V; I = {: 10.4g} A; IGr = {: 10.4g} A"
.format(meas[u"keihv_srcvoltage"],
meas[u"keihv_current"],
meas[u"kei6485_current"]))
else:
meas[u"kei6485_current"] = 0
print(u"VSrc = {: 10.4g} V; I = {: 10.4g} A".format(
meas[u"keihv_srcvoltage"], meas[u"keihv_current"]))
if (abs(meas[u"keihv_current"]) >= args.compcurrent or
abs(meas[u"kei6485_current"]) >= args.compcurrent):
self.error_signal.emit(u"Compliance current reached")
print(u"Compliance current reached")
#Instant turn off
keith_hv.set_output_state(False)
self._exiting = True
writer.writerow(meas)
if args.guardring:
self.measurement_ready.emit(
(meas[u"keihv_srcvoltage"], meas[u"keihv_current"],
meas[u"kei6485_current"]))
else:
self.measurement_ready.emit((meas[u"keihv_srcvoltage"],
meas[u"keihv_current"]))
if self._exiting:
break
except IOError as e:
errormsg = u"Error: {}".format(e)
self.error_signal.emit(errormsg)
logger.error(errormsg)
except (VisaIOError, InvalidBinaryFormat, ValueError):
errormsg = u"Error during communication with devices."
self.error_signal.emit(errormsg)
logger.error(errormsg)
finally:
logger.info(u"Stopping measurement")
try:
keith_hv.stop_measurement()
except (VisaIOError, InvalidBinaryFormat, ValueError):
logger.error(u"Error during stopping. Trying turn off output")
keith_hv.set_output_state(False)
self.finished.emit(os.path.join(str(args.output_dir), fname))
def run(self):
args = self.args
fname = getDateTimeFilename()
output_csv = os.path.join(str(args.output_dir), fname + u".csv")
logger = logging.getLogger(u'myLogger')
logger.debug(u' In cv_measurement.py:')
try:
keith6517B = keithley.Keithley6517B(args.devname_kei6517b)
logger.info(
u"Voltage source device introduced itself as {}".format(
keith6517B.identify()))
agilentE4980A = agilent.AgilentE4980A(args.devname_agiE4980A)
logger.info(u"LCR meter introduced itself as {}".format(
agilentE4980A.identify()))
except VisaIOError:
errormsg = u"Could not open devices."
self.error_signal.emit(errormsg)
logger.error(errormsg)
self.finished.emit(os.path.join(str(args.output_dir), fname))
return
try:
logger.info(u"Starting measurement")
agilentE4980A.set_frequency(args.frequency)
agilentE4980A.set_voltage_level(args.deltavolt)
mode = 'w'
if sys.version_info.major < 3:
mode += 'b'
with open(output_csv, mode) as f:
header = OrderedDict([('kei6517b_srcvoltage', None),
('agie4980a_capacitance', None),
('agie4980a_conductance', None)])
writer = csv.DictWriter(f,
fieldnames=header,
extrasaction=u"ignore")
writer.writeheader()
for keivolt in keith6517B.voltage_series(
args.start, args.end, args.step):
sleep(args.sleep)
if self._exiting:
break
line = agilentE4980A.get_reading()
meas = agilent.parse_cgv(line, u"agie4980a")
meas[u"kei6517b_srcvoltage"] = keivolt
if (not u"kei6517b_srcvoltage" in meas
or not u"agie4980a_capacitance" in meas
or not u"agie4980a_conductance" in meas
or meas[u"kei6517b_srcvoltage"] is None
or meas[u"agie4980a_capacitance"] is None
or meas[u"agie4980a_conductance"] is None):
raise IOError(u"Got invalid reading from device")
print(
u"VSrc = {: 10.4g} V; C = {: 10.4g} F; G = {: 10.4g} S"
.format(meas[u"kei6517b_srcvoltage"],
meas[u"agie4980a_capacitance"],
meas[u"agie4980a_conductance"]))
writer.writerow(meas)
self.measurement_ready.emit(
(meas[u"kei6517b_srcvoltage"],
1 / meas[u"agie4980a_capacitance"]**2))
if self._exiting:
break
except IOError as e:
errormsg = u"Error: {}".format(e)
self.error_signal.emit(errormsg)
logger.error(errormsg)
except (VisaIOError, InvalidBinaryFormat, ValueError):
errormsg = u"Error during communication with devices."
self.error_signal.emit(errormsg)
logger.error(errormsg)
finally:
logger.info(u"Stopping measurement")
try:
keith6517B.stop_measurement()
except (VisaIOError, InvalidBinaryFormat, ValueError):
logger.error(
u"Error during stopping. Trying to turn off output")
keith6517B.set_output_state(False)
self.finished.emit(os.path.join(str(args.output_dir), fname))
def run(self):
args = self.args
fname = getDateTimeFilename()
output_csv = os.path.join(str(args.output_dir), fname + u".csv")
logger = logging.getLogger(
u'probestation.strip_measurement.StripMeasurementThread')
logger.debug(u" In strip_measurement.py:")
try:
if args.devname_ardenv:
if not self._init_envsensor():
errormsg = u"Could not open environment sensor device."
self.error_signal.emit(errormsg)
logger.error(errormsg)
self.finished.emit(
os.path.join(str(args.output_dir), fname))
input_hv = keithley.KeithleyMeter(args.devname_hv,
args.serialenable)
if input_hv.identify().startswith(
u"KEITHLEY INSTRUMENTS INC.,MODEL 6517B"):
keith_hv = keithley.Keithley6517B(args.devname_hv,
args.serialenable)
elif input_hv.identify().startswith(
u"KEITHLEY INSTRUMENTS INC.,MODEL 2410"):
keith_hv = keithley.Keithley2410(args.devname_hv,
args.serialenable)
else:
errormsg = u"Could not open devices."
self.error_signal.emit(errormsg)
logger.error(errormsg)
self.finished.emit(os.path.join(str(args.output_dir), fname))
return
logger.info(
u" Voltage source device introduced itself as {}".format(
keith_hv.identify()))
agilentE4980A = agilent.AgilentE4980A(args.devname_agiE4980A,
args.serialenable)
logger.info(u"LCR meter introduced itself as {}".format(
agilentE4980A.identify()))
except VisaIOError:
errormsg = u"Could not open devices."
self.error_signal.emit(errormsg)
logger.error(errormsg)
self.finished.emit(os.path.join(str(args.output_dir), fname))
return
try:
logger.info(u"Starting measurement")
if args.resistance:
logger.info(u"Resistance!")
agilentE4980A.set_frequency(args.frequency)
agilentE4980A.set_voltage_level(args.deltavolt)
mode = 'w'
if sys.version_info.major < 3:
mode += 'b'
keith_hv.set_compliance(args.compcurrent)
with open(output_csv, mode) as f:
if not args.resistance:
header = OrderedDict([('keihv_srcvoltage', None),
('agie4980a_capacitance', None),
('keihv_current', None)])
else:
header = OrderedDict([('keihv_srcvoltage', None),
('agie4980a_resistance', None),
('agie4980a_impedance', None),
('keihv_current', None)])
if args.devname_ardenv:
header.update({
'envsensor1_temperature': None,
'envsensor1_dewpoint': None,
'envsensor2_temperature': None,
'envsensor2_dewpoint': None
})
writer = csv.DictWriter(f, header, extrasaction="ignore")
writer.writeheader()
for keivolt in keith_hv.voltage_series(args.start, args.end,
args.step):
sleep(args.sleep)
if self._exiting:
break
if not args.resistance:
line = agilentE4980A.get_reading()
meas = agilent.parse_cgv(line, "agie4980a")
meas["keihv_srcvoltage"] = keivolt
if (not "keihv_srcvoltage" in meas
or not "agie4980a_capacitance" in meas
or not "agie4980a_conductance" in meas
or meas["keihv_srcvoltage"] is None
or meas["agie4980a_capacitance"] is None
or meas["agie4980a_conductance"] is None):
raise IOError("Got invalid reading from device")
compline = keith_hv.get_reading()
meas.update(keith_hv.parse_iv(compline, u"keihv"))
print(
"VSrc = {: 10.4g} V; C = {: 10.4g} F; G = {: 10.4g} S"
.format(meas["keihv_srcvoltage"],
meas["agie4980a_capacitance"],
meas["agie4980a_conductance"]))
else:
line = agilentE4980A.get_resistance()
meas = agilent.parse_res(line, "agie4980a")
meas["keihv_srcvoltage"] = keivolt
if (not "keihv_srcvoltage" in meas
or not "agie4980a_resistance" in meas
or not "agie4980a_impedance" in meas
or meas["keihv_srcvoltage"] is None
or meas["agie4980a_resistance"] is None
or meas["agie4980a_impedance"] is None):
raise IOError("Got invalid reading from device")
compline = keith_hv.get_reading()
meas.update(keith_hv.parse_iv(compline, u"keihv"))
print("VSrc = {: 10.4g} V; R = {: 10.4g} O".format(
meas["keihv_srcvoltage"],
meas["agie4980a_resistance"],
meas["agie4980a_impedance"]))
if (abs(meas[u"keihv_current"]) >= args.compcurrent):
self.error_signal.emit(u"Compliance current reached")
print(u"Compliance current reached")
#Instant turn off
keith_hv.set_output_state(False)
self._exiting = True
if args.devname_ardenv:
env = self._measure_environment()
meas.update(env)
writer.writerow(meas)
if not args.resistance:
self.measurement_ready.emit(
(meas["keihv_srcvoltage"],
meas["agie4980a_capacitance"]))
else:
self.measurement_ready.emit(
(meas["keihv_srcvoltage"],
meas["agie4980a_resistance"],
meas["agie4980a_impedance"]))
if self._exiting:
break
except IOError as e:
errormsg = u"Error: {}".format(e)
self.error_signal.emit(errormsg)
logger.error(errormsg)
except (VisaIOError, InvalidBinaryFormat, ValueError):
errormsg = u"Error during communication with devices."
self.error_signal.emit(errormsg)
logger.error(errormsg)
finally:
logger.info(u"Stopping measurement")
try:
keith_hv.stop_measurement()
except (VisaIOError, InvalidBinaryFormat, ValueError):
logger.error(
u"Error during stopping. Trying to turn off output")
keith_hv.set_output_state(False)
self.finished.emit(os.path.join(str(args.output_dir), fname))
