def finalize(self, hvsrc, vsrc, elm): self.process.emit("progress", 0, 2) try: self.elm_set_zero_check(elm, True) assert self.elm_get_zero_check(elm) == True, "failed to enable zero check" finally: self.process.emit("message", "Ramp to zero...") self.process.emit("progress", 1, 2) self.process.emit("state", dict( elm_current=None, vsrc_current=None, hvsrc_current=None )) voltage_step = self.get_parameter('voltage_step') voltage = self.hvsrc_get_voltage_level(hvsrc) logging.info("HV Source ramp to zero: from %E V to %E V with step %E V", voltage, 0, 1.0) for voltage in comet.Range(voltage, 0, 1.0): self.process.emit("message", "Ramp to zero... {}".format(format_metric(voltage, "V"))) self.hvsrc_set_voltage_level(hvsrc, voltage) self.process.emit("state", dict( hvsrc_voltage=voltage, )) time.sleep(QUICK_RAMP_DELAY) bias_voltage = self.vsrc_get_voltage_level(vsrc) logging.info("V Source ramp bias to zero: from %E V to %E V with step %E V", bias_voltage, 0, 1.0) for voltage in comet.Range(bias_voltage, 0, 1.0): self.process.emit("message", "Ramp bias to zero... {}".format(format_metric(voltage, "V"))) self.vsrc_set_voltage_level(vsrc, voltage) self.process.emit("state", dict( vsrc_voltage=voltage, )) time.sleep(QUICK_RAMP_DELAY) self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_OFF) self.vsrc_set_output_state(vsrc, vsrc.OUTPUT_OFF) self.process.emit("state", dict( hvsrc_output=self.hvsrc_get_output_state(hvsrc), hvsrc_voltage=None, hvsrc_current=None, vsrc_output=self.vsrc_get_output_state(vsrc), vsrc_voltage=None, vsrc_current=None, env_chuck_temperature=None, env_box_temperature=None, env_box_humidity=None )) self.process.emit("progress", 2, 2)
def finalize(self, hvsrc, vsrc): self.process.emit("progress", 1, 2) self.process.emit("message", "Ramp to zero...") voltage_step_after = self.get_parameter( 'voltage_step_after') or self.get_parameter('voltage_step') waiting_time_after = self.get_parameter('waiting_time_after') waiting_time_end = self.get_parameter('waiting_time_end') voltage = self.hvsrc_get_voltage_level(hvsrc) logger.info("HV Source ramp to zero: from %E V to %E V with step %E V", voltage, 0, voltage_step_after) for voltage in comet.Range(voltage, 0, voltage_step_after): self.process.emit( "message", "Ramp to zero... {}".format(format_metric(voltage, "V"))) self.hvsrc_set_voltage_level(hvsrc, voltage) self.process.emit("state", dict(hvsrc_voltage=voltage, )) time.sleep(waiting_time_after) bias_voltage = self.vsrc_get_voltage_level(vsrc) logger.info( "V Source ramp bias to zero: from %E V to %E V with step %E V", bias_voltage, 0, voltage_step_after) for voltage in comet.Range(bias_voltage, 0, voltage_step_after): self.process.emit( "message", "Ramp bias to zero... {}".format(format_metric(voltage, "V"))) self.vsrc_set_voltage_level(vsrc, voltage) self.process.emit("state", dict(vsrc_voltage=voltage, )) time.sleep(waiting_time_after) # Waiting time after ramp down. self.wait(waiting_time_end) self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_OFF) self.vsrc_set_output_state(vsrc, vsrc.OUTPUT_OFF) self.process.emit( "state", dict(hvsrc_output=self.hvsrc_get_output_state(hvsrc), hvsrc_voltage=None, hvsrc_current=None, vsrc_output=self.vsrc_get_output_state(vsrc), vsrc_voltage=None, vsrc_current=None, env_chuck_temperature=None, env_box_temperature=None, env_box_humidity=None)) self.process.emit("progress", 2, 2)
def quick_ramp_zero(self, hvsrc): """Ramp to zero voltage without measuring current.""" self.process.emit("message", "Ramp to zero...") self.process.emit("progress", 0, 1) bias_voltage_step = self.get_parameter('bias_voltage_step') hvsrc_output_state = self.hvsrc_get_output_state(hvsrc) self.process.emit("state", dict( hvsrc_output=hvsrc_output_state )) if hvsrc_output_state: hvsrc_voltage_level = self.hvsrc_get_voltage_level(hvsrc) ramp = comet.Range(hvsrc_voltage_level, 0, bias_voltage_step) for step, voltage in enumerate(ramp): self.process.emit("progress", step + 1, ramp.count) self.hvsrc_set_voltage_level(hvsrc, voltage) self.process.emit("state", dict( hvsrc_voltage=voltage )) time.sleep(QUICK_RAMP_DELAY) hvsrc_output_state = self.hvsrc_get_output_state(hvsrc) self.process.emit("state", dict( hvsrc_output=hvsrc_output_state )) self.process.emit("message", "") self.process.emit("progress", 1, 1)
def finalize(self, vsrc): self.process.emit("progress", 1, 2) self.process.emit("state", dict(vsrc_voltage=None)) current_step = self.get_parameter('current_step') current = self.vsrc_get_current_level(vsrc) logging.info("V Source ramp to zero: from %E A to %E A with step %E A", current, 0, current_step) for current in comet.Range(current, 0, current_step): self.process.emit( "message", "Ramp to zero... {}".format(format_metric(current, "A"))) self.vsrc_set_current_level(vsrc, current) self.process.emit("state", dict(vsrc_current=current, )) time.sleep(QUICK_RAMP_DELAY) self.vsrc_set_output_state(vsrc, vsrc.OUTPUT_OFF) self.vsrc_check_error(vsrc) self.process.emit( "state", dict(vsrc_output=self.vsrc_get_output_state(vsrc), env_chuck_temperature=None, env_box_temperature=None, env_box_humidity=None)) self.process.emit("progress", 2, 2)
def quick_ramp_zero(self, lcr): """Ramp to zero voltage without measuring current.""" self.process.emit("message", "Ramp to zero...") self.process.emit("progress", 0, 1) bias_voltage_step_after = self.get_parameter('bias_voltage_step_after') or self.get_parameter('bias_voltage_step') waiting_time_after = self.get_parameter('waiting_time_after') lcr_output=self.lcr_get_bias_state(lcr) self.process.emit("state", dict( lcr_output=lcr_output )) if lcr_output: lcr_voltage_level = self.lcr_get_bias_voltage_level(lcr) ramp = comet.Range(lcr_voltage_level, 0, bias_voltage_step_after) for step, voltage in enumerate(ramp): self.process.emit("progress", step + 1, ramp.count) self.lcr_set_bias_voltage_level(lcr, voltage) self.process.emit("state", dict( lcr_voltage=voltage )) time.sleep(waiting_time_after) self.process.emit("state", dict( lcr_output=self.lcr_get_bias_state(lcr) )) self.process.emit("message", "") self.process.emit("progress", 1, 1)
def finalize(self, hvsrc): voltage_step = self.get_parameter('voltage_step') voltage = self.hvsrc_get_voltage_level(hvsrc) self.process.emit( "state", dict(hvsrc_voltage=voltage, hvsrc_current=None, hvsrc_output=self.hvsrc_get_output_state(hvsrc))) logging.info( "HV Source ramp to zero: from %E V to %E V with step %E V", voltage, 0, voltage_step) for voltage in comet.Range(voltage, 0, voltage_step): self.process.emit( "message", "Ramp to zero... {}".format(format_metric(voltage, "V"))) self.hvsrc_set_voltage_level(hvsrc, voltage) self.process.emit("state", dict(hvsrc_voltage=voltage)) time.sleep(QUICK_RAMP_DELAY) self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_OFF) self.process.emit( "state", dict(hvsrc_voltage=self.hvsrc_get_voltage_level(hvsrc), hvsrc_output=self.hvsrc_get_output_state(hvsrc))) self.process.emit("progress", 5, 5)
def safe_initialize_vsrc(self, resource): context = settings.vsrc_instrument(resource) if context.get_output() == context.OUTPUT_ON: self.emit("message", "Ramping down V Source...") start_voltage = context.get_source_voltage() stop_voltage = 0.0 step_voltage = min(25.0, max(5.0, start_voltage / 100.)) for voltage in comet.Range(start_voltage, stop_voltage, step_voltage): context.set_source_voltage(voltage) self.emit("message", "Disable output V Source...") context.set_output(context.OUTPUT_OFF) self.emit("message", "Initialized VSource.")
def finalize(self, hvsrc, elm): self.process.emit("progress", 0, 2) voltage_step_after = self.get_parameter( 'voltage_step_after') or self.get_parameter('voltage_step') waiting_time_after = self.get_parameter('waiting_time_after') waiting_time_end = self.get_parameter('waiting_time_end') try: self.elm_set_zero_check(elm, True) assert self.elm_get_zero_check( elm) == True, "failed to enable zero check" finally: self.process.emit("message", "Ramp to zero...") self.process.emit("progress", 1, 2) self.process.emit("state", dict(hvsrc_current=None, elm_current=None)) voltage = self.hvsrc_get_voltage_level(hvsrc) logger.info( "HV Source ramp to zero: from %E V to %E V with step %E V", voltage, 0, voltage_step_after) for voltage in comet.Range(voltage, 0, voltage_step_after): self.process.emit( "message", "Ramp to zero... {}".format(format_metric(voltage, "V"))) self.hvsrc_set_voltage_level(hvsrc, voltage) self.process.emit("state", dict(hvsrc_voltage=voltage, )) time.sleep(waiting_time_after) # Waiting time after ramp down. self.wait(waiting_time_end) self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_OFF) self.process.emit( "state", dict(hvsrc_output=self.hvsrc_get_output_state(hvsrc), env_chuck_temperature=None, env_box_temperature=None, env_box_humidity=None)) self.process.emit("progress", 2, 2)
def finalize(self, vsrc): self.process.emit("progress", 1, 2) self.process.emit("state", dict(vsrc_voltage=None)) current_step_after = self.get_parameter( 'current_step_after') or self.get_parameter('current_step') waiting_time_after = self.get_parameter('waiting_time_after') waiting_time_end = self.get_parameter('waiting_time_end') current = self.vsrc_get_current_level(vsrc) logger.info("V Source ramp to zero: from %E A to %E A with step %E A", current, 0, current_step_after) for current in comet.Range(current, 0, current_step_after): self.process.emit( "message", "Ramp to zero... {}".format(format_metric(current, "A"))) self.vsrc_set_current_level(vsrc, current) self.process.emit("state", dict(vsrc_current=current, )) time.sleep(waiting_time_after) # Waiting time after ramp down. self.wait(waiting_time_end) self.vsrc_set_output_state(vsrc, vsrc.OUTPUT_OFF) self.vsrc_check_error(vsrc) self.process.emit( "state", dict(vsrc_output=self.vsrc_get_output_state(vsrc), env_chuck_temperature=None, env_box_temperature=None, env_box_humidity=None)) self.process.emit("progress", 2, 2)
def quick_ramp_zero(self, vsrc): """Ramp to zero voltage without measuring current.""" self.process.emit("message", "Ramp to zero...") self.process.emit("progress", 0, 1) bias_voltage_step_after = self.get_parameter( 'bias_voltage_step_after') or self.get_parameter( 'bias_voltage_step') waiting_time_after = self.get_parameter('waiting_time_after') vsrc_output_state = self.vsrc_get_output_state(vsrc) self.process.emit("state", dict(vsrc_output=vsrc_output_state)) if vsrc_output_state: vsrc_voltage_level = self.vsrc_get_voltage_level(vsrc) ramp = comet.Range(vsrc_voltage_level, 0, bias_voltage_step_after) for step, voltage in enumerate(ramp): self.process.emit("progress", step + 1, ramp.count) self.vsrc_set_voltage_level(vsrc, voltage) self.process.emit("state", dict(vsrc_voltage=voltage)) time.sleep(waiting_time_after) self.process.emit("state", dict(vsrc_output=self.vsrc_get_output_state(vsrc))) self.process.emit("message", "") self.process.emit("progress", 1, 1)
def measure(self, vsrc): current_start = self.get_parameter('current_start') current_step = self.get_parameter('current_step') current_stop = self.get_parameter('current_stop') waiting_time = self.get_parameter('waiting_time') vsrc_voltage_compliance = self.get_parameter('vsrc_voltage_compliance') if not self.process.running: return current = self.vsrc_get_current_level(vsrc) ramp = comet.Range(current, current_stop, current_step) est = Estimate(ramp.count) self.process.emit("progress", *est.progress) t0 = time.time() logging.info( "V Source ramp to end current: from %E A to %E A with step %E A", current, ramp.end, ramp.step) for current in ramp: self.vsrc_clear(vsrc) self.vsrc_set_current_level(vsrc, current) self.process.emit("state", dict(vsrc_current=current, )) time.sleep(waiting_time) dt = time.time() - t0 est.advance() self.process.emit( "message", "{} | V Source {}".format(format_estimate(est), format_metric(current, "A"))) self.process.emit("progress", *est.progress) # read V Source vsrc_reading = self.vsrc_read_voltage(vsrc) self.process.emit("reading", "vsrc", abs(current) if ramp.step < 0 else current, vsrc_reading) self.process.emit("update") self.process.emit("state", dict(vsrc_voltage=vsrc_reading)) self.environment_update() self.process.emit( "state", dict(env_chuck_temperature=self.environment_temperature_chuck, env_box_temperature=self.environment_temperature_box, env_box_humidity=self.environment_humidity_box)) # Append series data self.append_series( timestamp=dt, current=current, voltage_vsrc=vsrc_reading, temperature_box=self.environment_temperature_box, temperature_chuck=self.environment_temperature_chuck, humidity_box=self.environment_humidity_box) # Compliance tripped? self.vsrc_check_compliance(vsrc) if not self.process.running: break
def initialize(self, hvsrc, lcr): self.process.emit("progress", 1, 6) # Parameters bias_voltage_start = self.get_parameter('bias_voltage_start') bias_voltage_step = self.get_parameter('bias_voltage_step') bias_voltage_stop = self.get_parameter('bias_voltage_stop') waiting_time = self.get_parameter('waiting_time') bias_voltage_step_before = self.get_parameter( 'bias_voltage_step_before') or self.get_parameter( 'bias_voltage_step') waiting_time_before = self.get_parameter('waiting_time_before') bias_voltage_step_after = self.get_parameter( 'bias_voltage_step_after') or self.get_parameter( 'bias_voltage_step') waiting_time_after = self.get_parameter('waiting_time_after') waiting_time_start = self.get_parameter('waiting_time_start') waiting_time_end = self.get_parameter('waiting_time_end') hvsrc_current_compliance = self.get_parameter( 'hvsrc_current_compliance') hvsrc_accept_compliance = self.get_parameter('hvsrc_accept_compliance') # Extend meta data self.set_meta("bias_voltage_start", f"{bias_voltage_start:G} V") self.set_meta("bias_voltage_stop", f"{bias_voltage_stop:G} V") self.set_meta("bias_voltage_step", f"{bias_voltage_step:G} V") self.set_meta("waiting_time", f"{waiting_time:G} s") self.set_meta("bias_voltage_step_before", f"{bias_voltage_step_before:G} V") self.set_meta("waiting_time_before", f"{waiting_time_before:G} s") self.set_meta("bias_voltage_step_after", f"{bias_voltage_step_after:G} V") self.set_meta("waiting_time_after", f"{waiting_time_after:G} s") self.set_meta("waiting_time_start", f"{waiting_time_start:G} s") self.set_meta("waiting_time_end", f"{waiting_time_end:G} s") self.set_meta("hvsrc_current_compliance", f"{hvsrc_current_compliance:G} A") self.set_meta("hvsrc_accept_compliance", hvsrc_accept_compliance) self.hvsrc_update_meta() self.lcr_update_meta() self.environment_update_meta() # Series units self.set_series_unit("timestamp", "s") self.set_series_unit("voltage_hvsrc", "V") self.set_series_unit("current_hvsrc", "A") self.set_series_unit("capacitance", "F") self.set_series_unit("capacitance2", "1") self.set_series_unit("resistance", "Ohm") self.set_series_unit("temperature_box", "degC") self.set_series_unit("temperature_chuck", "degC") self.set_series_unit("humidity_box", "%") # Series self.register_series("timestamp") self.register_series("voltage_hvsrc") self.register_series("current_hvsrc") self.register_series("capacitance") self.register_series("capacitance2") self.register_series("resistance") self.register_series("temperature_box") self.register_series("temperature_chuck") self.register_series("humidity_box") # Initialize HV Source self.hvsrc_reset(hvsrc) self.process.emit("progress", 3, 6) self.hvsrc_setup(hvsrc) hvsrc_current_compliance = self.get_parameter( 'hvsrc_current_compliance') self.hvsrc_set_current_compliance(hvsrc, hvsrc_current_compliance) self.process.emit("progress", 4, 6) self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_ON) hvsrc_output_state = self.hvsrc_get_output_state(hvsrc) self.process.emit("state", dict(hvsrc_output=hvsrc_output_state, )) # Initialize LCR self.lcr_reset(lcr) self.lcr_setup(lcr) self.process.emit("progress", 5, 6) # Ramp to start voltage hvsrc_voltage_level = self.hvsrc_get_voltage_level(hvsrc) logger.info( "HV Source ramp to start voltage: from %E V to %E V with step %E V", hvsrc_voltage_level, bias_voltage_start, bias_voltage_step_before) for voltage in comet.Range(hvsrc_voltage_level, bias_voltage_start, bias_voltage_step_before): self.process.emit( "message", "Ramp to start... {}".format(format_metric(voltage, "V"))) self.hvsrc_set_voltage_level(hvsrc, voltage) time.sleep(waiting_time_before) self.process.emit("state", dict(hvsrc_voltage=voltage, )) # Compliance tripped? self.hvsrc_check_compliance(hvsrc) if not self.process.running: break # Waiting time before measurement ramp. self.wait(waiting_time_start) self.process.emit("progress", 6, 6)
def measure(self, hvsrc, lcr): self.process.emit("progress", 1, 2) # Parameters bias_voltage_step = self.get_parameter('bias_voltage_step') bias_voltage_stop = self.get_parameter('bias_voltage_stop') waiting_time = self.get_parameter('waiting_time') hvsrc_current_compliance = self.get_parameter( 'hvsrc_current_compliance') hvsrc_accept_compliance = self.get_parameter('hvsrc_accept_compliance') lcr_soft_filter = self.get_parameter('lcr_soft_filter') if not self.process.running: return hvsrc_voltage_level = self.hvsrc_get_voltage_level(hvsrc) ramp = comet.Range(hvsrc_voltage_level, bias_voltage_stop, bias_voltage_step) est = Estimate(ramp.count) self.process.emit("progress", *est.progress) t0 = time.time() self.hvsrc_clear(hvsrc) benchmark_step = Benchmark("Single_Step") benchmark_lcr = Benchmark("Read_LCR") benchmark_hvsrc = Benchmark("Read_HV_Source") benchmark_environ = Benchmark("Read_Environment") logger.info( "HV Source ramp to end voltage: from %E V to %E V with step %E V", hvsrc_voltage_level, ramp.end, ramp.step) for voltage in ramp: with benchmark_step: self.hvsrc_set_voltage_level(hvsrc, voltage) # Delay time.sleep(waiting_time) dt = time.time() - t0 est.advance() self.process.emit( "message", "{} | HV Source {}".format(format_estimate(est), format_metric(voltage, "V"))) self.process.emit("progress", *est.progress) self.environment_update() # read HV Source with benchmark_hvsrc: hvsrc_reading = self.hvsrc_read_current(hvsrc) self.process.emit("update", ) self.process.emit( "state", dict(hvsrc_voltage=voltage, hvsrc_current=hvsrc_reading)) # read LCR, for CpRp -> prim: Cp, sec: Rp with benchmark_lcr: try: if lcr_soft_filter: lcr_prim, lcr_sec = self.lcr_acquire_filter_reading( lcr) else: lcr_prim, lcr_sec = self.lcr_acquire_reading(lcr) except Exception as exc: raise RuntimeError( f"Failed to read from LCR: {exc}") from exc try: lcr_prim2 = 1.0 / (lcr_prim * lcr_prim) except ZeroDivisionError: lcr_prim2 = 0.0 self.process.emit("reading", "lcr", abs(voltage) if ramp.step < 0 else voltage, lcr_prim) self.process.emit("reading", "lcr2", abs(voltage) if ramp.step < 0 else voltage, lcr_prim2) # Append series data self.append_series( timestamp=dt, voltage_hvsrc=voltage, current_hvsrc=hvsrc_reading, capacitance=lcr_prim, capacitance2=lcr_prim2, resistance=lcr_sec, temperature_box=self.environment_temperature_box, temperature_chuck=self.environment_temperature_chuck, humidity_box=self.environment_humidity_box) # Compliance tripped? if hvsrc_accept_compliance: if self.hvsrc_compliance_tripped(hvsrc): logger.info( "HV Source compliance tripped, gracefully stopping measurement." ) break else: self.hvsrc_check_compliance(hvsrc) if not self.process.running: break logger.info(benchmark_step) logger.info(benchmark_lcr) logger.info(benchmark_hvsrc) logger.info(benchmark_environ)
def measure(self, hvsrc, vsrc, elm): self.process.emit("progress", 1, 2) # Parameters voltage_start = self.get_parameter('voltage_start') voltage_stop = self.get_parameter('voltage_stop') voltage_step = self.get_parameter('voltage_step') waiting_time = self.get_parameter('waiting_time') bias_voltage = self.get_parameter('bias_voltage') bias_mode = self.get_parameter('bias_mode') elm_read_timeout = self.get_parameter('elm_read_timeout') if not self.process.running: return # Electrometer reading format: READ elm.resource.write(":FORM:ELEM READ") elm.resource.query("*OPC?") self.elm_check_error(elm) voltage = self.hvsrc_get_voltage_level(hvsrc) ramp = comet.Range(voltage, voltage_stop, voltage_step) est = Estimate(ramp.count) self.process.emit("progress", *est.progress) t0 = time.time() benchmark_step = Benchmark("Single_Step") benchmark_elm = Benchmark("Read_ELM") benchmark_hvsrc = Benchmark("Read_HV_Source") benchmark_vsrc = Benchmark("Read_V_Source") benchmark_environ = Benchmark("Read_Environment") logging.info("HV Source ramp to end voltage: from %E V to %E V with step %E V", voltage, ramp.end, ramp.step) for voltage in ramp: with benchmark_step: self.hvsrc_set_voltage_level(hvsrc, voltage) self.process.emit("state", dict( hvsrc_voltage=voltage, )) # Move bias TODO if bias_mode == "offset": bias_voltage += abs(ramp.step) if ramp.begin <= ramp.end else -abs(ramp.step) self.vsrc_set_voltage_level(vsrc, bias_voltage) self.process.emit("state", dict( vsrc_voltage=bias_voltage, )) time.sleep(waiting_time) dt = time.time() - t0 est.advance() self.process.emit("message", "{} | HV Source {} | Bias {}".format(format_estimate(est), format_metric(voltage, "V"), format_metric(bias_voltage, "V"))) self.process.emit("progress", *est.progress) # read ELM with benchmark_elm: try: elm_reading = self.elm_read(elm, timeout=elm_read_timeout) except Exception as exc: raise RuntimeError(f"Failed to read from ELM: {exc}") from exc self.elm_check_error(elm) logging.info("ELM reading: %s", format_metric(elm_reading, "A")) self.process.emit("reading", "elm", abs(voltage) if ramp.step < 0 else voltage, elm_reading) # read V Source with benchmark_vsrc: vsrc_reading = self.vsrc_read_current(vsrc) # read HV Source with benchmark_hvsrc: hvsrc_reading = self.hvsrc_read_current(hvsrc) self.process.emit("update") self.process.emit("state", dict( elm_current=elm_reading, hvsrc_current=hvsrc_reading, vsrc_current=vsrc_reading, )) self.environment_update() self.process.emit("state", dict( env_chuck_temperature=self.environment_temperature_chuck, env_box_temperature=self.environment_temperature_box, env_box_humidity=self.environment_humidity_box )) # Append series data self.append_series( timestamp=dt, voltage=voltage, current_elm=elm_reading, current_vsrc=vsrc_reading, current_hvsrc=hvsrc_reading, bias_voltage=bias_voltage, temperature_box=self.environment_temperature_box, temperature_chuck=self.environment_temperature_chuck, humidity_box=self.environment_humidity_box ) # Compliance tripped? self.hvsrc_check_compliance(hvsrc) self.vsrc_check_compliance(vsrc) if not self.process.running: break logging.info(benchmark_step) logging.info(benchmark_elm) logging.info(benchmark_hvsrc) logging.info(benchmark_vsrc) logging.info(benchmark_environ) self.process.emit("progress", 2, 2)
def measure(self, hvsrc): # Parameters voltage_start = self.get_parameter('voltage_start') voltage_stop = self.get_parameter('voltage_stop') voltage_step = self.get_parameter('voltage_step') waiting_time = self.get_parameter('waiting_time') hvsrc_accept_compliance = self.get_parameter('hvsrc_accept_compliance') if not self.process.running: return voltage = self.hvsrc_get_voltage_level(hvsrc) t0 = time.time() ramp = comet.Range(voltage, voltage_stop, voltage_step) est = Estimate(ramp.count) self.process.emit("progress", *est.progress) logger.info( "HV Source ramp to end voltage: from %E V to %E V with step %E V", voltage, ramp.end, ramp.step) for voltage in ramp: self.hvsrc_set_voltage_level(hvsrc, voltage) time.sleep(waiting_time) td = time.time() - t0 self.environment_update() reading_current = self.hvsrc_read_current(hvsrc) self.process.emit("reading", "hvsrc", abs(voltage) if ramp.step < 0 else voltage, reading_current) self.process.emit("update") self.process.emit( "state", dict(hvsrc_voltage=voltage, hvsrc_current=reading_current)) # Append series data self.append_series( timestamp=td, voltage=voltage, current_hvsrc=reading_current, temperature_box=self.environment_temperature_box, temperature_chuck=self.environment_temperature_chuck, humidity_box=self.environment_humidity_box) est.advance() self.process.emit( "message", "{} | HV Source {}".format(format_estimate(est), format_metric(voltage, "V"))) self.process.emit("progress", *est.progress) # Compliance tripped? if hvsrc_accept_compliance: if self.hvsrc_compliance_tripped(hvsrc): logger.info( "HV Source compliance tripped, gracefully stopping measurement." ) break else: self.hvsrc_check_compliance(hvsrc) if not self.process.running: break self.process.emit("progress", 0, 0)
def initialize(self, hvsrc): self.process.emit("progress", 1, 4) # Parameters voltage_start = self.get_parameter('voltage_start') voltage_stop = self.get_parameter('voltage_stop') voltage_step = self.get_parameter('voltage_step') waiting_time = self.get_parameter('waiting_time') hvsrc_current_compliance = self.get_parameter( 'hvsrc_current_compliance') # Extend meta data self.set_meta("voltage_start", f"{voltage_start:G} V") self.set_meta("voltage_stop", f"{voltage_stop:G} V") self.set_meta("voltage_step", f"{voltage_step:G} V") self.set_meta("waiting_time", f"{waiting_time:G} s") self.set_meta("hvsrc_current_compliance", f"{hvsrc_current_compliance:G} A") self.hvsrc_update_meta() self.environment_update_meta() # Series units self.set_series_unit("timestamp", "s") self.set_series_unit("voltage", "V") self.set_series_unit("current_hvsrc", "A") self.set_series_unit("temperature_box", "degC") self.set_series_unit("temperature_chuck", "degC") self.set_series_unit("humidity_box", "%") # Series self.register_series("timestamp") self.register_series("voltage") self.register_series("current_hvsrc") self.register_series("temperature_box") self.register_series("temperature_chuck") self.register_series("humidity_box") self.process.emit( "state", dict(hvsrc_voltage=self.hvsrc_get_voltage_level(hvsrc), hvsrc_current=None, hvsrc_output=self.hvsrc_get_output_state(hvsrc))) self.hvsrc_reset(hvsrc) self.hvsrc_setup(hvsrc) hvsrc_current_compliance = self.get_parameter( 'hvsrc_current_compliance') self.hvsrc_set_current_compliance(hvsrc, hvsrc_current_compliance) self.process.emit("progress", 2, 4) # If output enabled if self.hvsrc_get_output_state(hvsrc): voltage = self.hvsrc_get_voltage_level(hvsrc) logging.info( "HV Source ramp to zero: from %E V to %E V with step %E V", voltage, 0, voltage_step) for voltage in comet.Range(voltage, 0, voltage_step): self.process.emit("message", f"{voltage:.3f} V") self.hvsrc_set_voltage_level(hvsrc, voltage) time.sleep(QUICK_RAMP_DELAY) if not self.process.running: break # If output disabled else: voltage = 0 self.hvsrc_set_voltage_level(hvsrc, voltage) self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_ON) time.sleep(.100) self.process.emit( "state", dict(hvsrc_voltage=voltage, hvsrc_output=self.hvsrc_get_output_state(hvsrc))) self.process.emit("progress", 3, 4) if self.process.running: voltage = self.hvsrc_get_voltage_level(hvsrc) logging.info( "HV Source ramp to start voltage: from %E V to %E V with step %E V", voltage, voltage_start, voltage_step) for voltage in comet.Range(voltage, voltage_start, voltage_step): self.process.emit( "message", "Ramp to start... {}".format(format_metric(voltage, "V"))) self.hvsrc_set_voltage_level(hvsrc, voltage) time.sleep(QUICK_RAMP_DELAY) # Compliance tripped? self.hvsrc_check_compliance(hvsrc) if not self.process.running: break self.process.emit( "state", dict(hvsrc_voltage=voltage, hvsrc_output=self.hvsrc_get_output_state(hvsrc))) self.process.emit("progress", 4, 4)
def measure(self, hvsrc, elm): # Parameters voltage_start = self.get_parameter('voltage_start') voltage_stop = self.get_parameter('voltage_stop') voltage_step = self.get_parameter('voltage_step') waiting_time = self.get_parameter('waiting_time') hvsrc_accept_compliance = self.get_parameter('hvsrc_accept_compliance') elm_read_timeout = self.get_parameter('elm_read_timeout') if not self.process.running: return voltage = self.hvsrc_get_voltage_level(hvsrc) # Electrometer reading format: READ elm.resource.write(":FORM:ELEM READ") elm.resource.query("*OPC?") self.elm_check_error(elm) ramp = comet.Range(voltage, voltage_stop, voltage_step) est = Estimate(ramp.count) self.process.emit("progress", *est.progress) t0 = time.time() benchmark_step = Benchmark("Single_Step") benchmark_elm = Benchmark("Read_ELM") benchmark_hvsrc = Benchmark("Read_HV_Source") benchmark_environ = Benchmark("Read_Environment") logger.info( "HV Source ramp to end voltage: from %E V to %E V with step %E V", voltage, ramp.end, ramp.step) for voltage in ramp: with benchmark_step: self.hvsrc_clear(hvsrc) self.hvsrc_set_voltage_level(hvsrc, voltage) time.sleep(waiting_time) dt = time.time() - t0 est.advance() self.process.emit( "message", "{} | V Source {}".format(format_estimate(est), format_metric(voltage, "V"))) self.process.emit("progress", *est.progress) self.environment_update() # read HV Source with benchmark_hvsrc: hvsrc_reading = self.hvsrc_read_current(hvsrc) self.process.emit("reading", "hvsrc", abs(voltage) if ramp.step < 0 else voltage, hvsrc_reading) # read ELM with benchmark_elm: try: elm_reading = self.elm_read(elm, timeout=elm_read_timeout) except Exception as exc: raise RuntimeError( f"Failed to read from ELM: {exc}") from exc self.elm_check_error(elm) logger.info("ELM reading: %s", format_metric(elm_reading, "A")) self.process.emit("reading", "elm", abs(voltage) if ramp.step < 0 else voltage, elm_reading) self.process.emit("update") self.process.emit( "state", dict(hvsrc_voltage=voltage, hvsrc_current=hvsrc_reading, elm_current=elm_reading)) # Append series data self.append_series( timestamp=dt, voltage=voltage, current_hvsrc=hvsrc_reading, current_elm=elm_reading, temperature_box=self.environment_temperature_box, temperature_chuck=self.environment_temperature_chuck, humidity_box=self.environment_humidity_box) # Compliance tripped? if hvsrc_accept_compliance: if self.hvsrc_compliance_tripped(hvsrc): logger.info( "HV Source compliance tripped, gracefully stopping measurement." ) break else: self.hvsrc_check_compliance(hvsrc) if not self.process.running: break logger.info(benchmark_step) logger.info(benchmark_elm) logger.info(benchmark_hvsrc) logger.info(benchmark_environ) self.process.emit("progress", 4, 5)
def initialize(self, hvsrc, vsrc): self.process.emit("progress", 1, 5) # Parameters voltage_start = self.get_parameter('voltage_start') voltage_stop = self.get_parameter('voltage_stop') voltage_step = self.get_parameter('voltage_step') waiting_time = self.get_parameter('waiting_time') voltage_step_before = self.get_parameter( 'voltage_step_before') or self.get_parameter('voltage_step') waiting_time_before = self.get_parameter('waiting_time_before') voltage_step_after = self.get_parameter( 'voltage_step_after') or self.get_parameter('voltage_step') waiting_time_after = self.get_parameter('waiting_time_after') waiting_time_start = self.get_parameter('waiting_time_start') waiting_time_end = self.get_parameter('waiting_time_end') bias_voltage = self.get_parameter('bias_voltage') bias_mode = self.get_parameter('bias_mode') hvsrc_current_compliance = self.get_parameter( 'hvsrc_current_compliance') hvsrc_accept_compliance = self.get_parameter('hvsrc_accept_compliance') vsrc_current_compliance = self.get_parameter('vsrc_current_compliance') vsrc_accept_compliance = self.get_parameter('vsrc_accept_compliance') # Extend meta data self.set_meta("voltage_start", f"{voltage_start:G} V") self.set_meta("voltage_stop", f"{voltage_stop:G} V") self.set_meta("voltage_step", f"{voltage_step:G} V") self.set_meta("waiting_time", f"{waiting_time:G} s") self.set_meta("voltage_step_before", f"{voltage_step_before:G} V") self.set_meta("waiting_time_before", f"{waiting_time_before:G} s") self.set_meta("voltage_step_after", f"{voltage_step_after:G} V") self.set_meta("waiting_time_after", f"{waiting_time_after:G} s") self.set_meta("waiting_time_start", f"{waiting_time_start:G} s") self.set_meta("waiting_time_end", f"{waiting_time_end:G} s") self.set_meta("bias_voltage", f"{bias_voltage:G} V") self.set_meta("hvsrc_current_compliance", f"{hvsrc_current_compliance:G} A") self.set_meta("hvsrc_accept_compliance", hvsrc_accept_compliance) self.hvsrc_update_meta() self.set_meta("vsrc_current_compliance", f"{vsrc_current_compliance:G} A") self.set_meta("vsrc_accept_compliance", vsrc_accept_compliance) self.vsrc_update_meta() self.environment_update_meta() # Series units self.set_series_unit("timestamp", "s") self.set_series_unit("voltage", "V") self.set_series_unit("current_vsrc", "A") self.set_series_unit("bias_voltage", "V") self.set_series_unit("temperature_box", "degC") self.set_series_unit("temperature_chuck", "degC") self.set_series_unit("humidity_box", "%") # Series self.register_series("timestamp") self.register_series("voltage") self.register_series("current_vsrc") self.register_series("bias_voltage") self.register_series("temperature_box") self.register_series("temperature_chuck") self.register_series("humidity_box") # Initialize HV Source self.hvsrc_reset(hvsrc) self.hvsrc_setup(hvsrc) self.hvsrc_set_current_compliance(hvsrc, hvsrc_current_compliance) self.process.emit( "state", dict(hvsrc_voltage=self.hvsrc_get_voltage_level(hvsrc), hvsrc_current=None, hvsrc_output=self.hvsrc_get_output_state(hvsrc))) if not self.process.running: return # Initialize V Source self.vsrc_reset(vsrc) self.vsrc_setup(vsrc) # Voltage source self.vsrc_set_function_voltage(vsrc) self.vsrc_set_current_compliance(vsrc, vsrc_current_compliance) if not self.process.running: return # Output enable self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_ON) time.sleep(.100) self.process.emit( "state", dict(hvsrc_output=self.hvsrc_get_output_state(hvsrc))) self.vsrc_set_output_state(vsrc, vsrc.OUTPUT_ON) time.sleep(.100) self.process.emit("state", dict(vsrc_output=self.vsrc_get_output_state(vsrc))) self.process.emit("message", "Ramp to start...") # Ramp HV Spource to bias voltage voltage = self.vsrc_get_voltage_level(vsrc) logger.info( "V Source ramp to bias voltage: from %E V to %E V with step %E V", voltage, bias_voltage, voltage_step_before) for voltage in comet.Range(voltage, bias_voltage, voltage_step_before): self.process.emit( "message", "Ramp to bias... {}".format(format_metric(voltage, "V"))) self.vsrc_set_voltage_level(vsrc, voltage) self.process.emit("state", dict(vsrc_voltage=voltage, )) time.sleep(waiting_time_before) # Compliance tripped? self.vsrc_check_compliance(vsrc) if not self.process.running: break # Ramp HV Source to start voltage voltage = self.hvsrc_get_voltage_level(hvsrc) logger.info( "HV Source ramp to start voltage: from %E V to %E V with step %E V", voltage, voltage_start, voltage_step_before) for voltage in comet.Range(voltage, voltage_start, voltage_step_before): self.process.emit( "message", "Ramp to start... {}".format(format_metric(voltage, "V"))) self.hvsrc_set_voltage_level(hvsrc, voltage) self.process.emit("state", dict(hvsrc_voltage=voltage, )) time.sleep(waiting_time_before) # Compliance tripped? self.hvsrc_check_compliance(hvsrc) if not self.process.running: break # Waiting time before measurement ramp. self.wait(waiting_time_start) self.process.emit("progress", 5, 5)
def initialize(self, hvsrc, vsrc, elm): self.process.emit("progress", 1, 5) # Parameters voltage_start = self.get_parameter('voltage_start') voltage_stop = self.get_parameter('voltage_stop') voltage_step = self.get_parameter('voltage_step') waiting_time = self.get_parameter('waiting_time') bias_voltage = self.get_parameter('bias_voltage') bias_mode = self.get_parameter('bias_mode') hvsrc_current_compliance = self.get_parameter('hvsrc_current_compliance') vsrc_current_compliance = self.get_parameter('vsrc_current_compliance') vsrc_sense_mode = self.get_parameter('vsrc_sense_mode') vsrc_filter_enable = self.get_parameter('vsrc_filter_enable') vsrc_filter_count = self.get_parameter('vsrc_filter_count') vsrc_filter_type = self.get_parameter('vsrc_filter_type') elm_filter_enable = self.get_parameter('elm_filter_enable') elm_filter_count = self.get_parameter('elm_filter_count') elm_filter_type = self.get_parameter('elm_filter_type') elm_zero_correction = self.get_parameter('elm_zero_correction') elm_integration_rate = self.get_parameter('elm_integration_rate') elm_current_range = self.get_parameter('elm_current_range') elm_current_autorange_enable = self.get_parameter('elm_current_autorange_enable') elm_current_autorange_minimum = self.get_parameter('elm_current_autorange_minimum') elm_current_autorange_maximum = self.get_parameter('elm_current_autorange_maximum') elm_read_timeout = self.get_parameter('elm_read_timeout') # Extend meta data self.set_meta("voltage_start", f"{voltage_start:G} V") self.set_meta("voltage_stop", f"{voltage_stop:G} V") self.set_meta("voltage_step", f"{voltage_step:G} V") self.set_meta("waiting_time", f"{waiting_time:G} s") self.set_meta("bias_voltage", f"{bias_voltage:G} V") self.set_meta("hvsrc_current_compliance", f"{hvsrc_current_compliance:G} A") self.hvsrc_update_meta() self.set_meta("vsrc_current_compliance", f"{vsrc_current_compliance:G} A") self.vsrc_update_meta() self.set_meta("elm_filter_enable", elm_filter_enable) self.set_meta("elm_filter_count", elm_filter_count) self.set_meta("elm_filter_type", elm_filter_type) self.set_meta("elm_zero_correction", elm_zero_correction) self.set_meta("elm_integration_rate", elm_integration_rate) self.set_meta("elm_current_range", format(elm_current_range, 'G')) self.set_meta("elm_current_autorange_enable", elm_current_autorange_enable) self.set_meta("elm_current_autorange_minimum", format(elm_current_autorange_minimum, 'G')) self.set_meta("elm_current_autorange_maximum", format(elm_current_autorange_maximum, 'G')) self.set_meta("elm_read_timeout", format(elm_read_timeout, 'G')) self.elm_update_meta() self.environment_update_meta() # Series units self.set_series_unit("timestamp", "s") self.set_series_unit("voltage", "V") self.set_series_unit("current_elm", "A") self.set_series_unit("current_vsrc", "A") self.set_series_unit("current_hvsrc", "A") self.set_series_unit("bias_voltage", "V") self.set_series_unit("temperature_box", "degC") self.set_series_unit("temperature_chuck", "degC") self.set_series_unit("humidity_box", "%") # Series self.register_series("timestamp") self.register_series("voltage") self.register_series("current_elm") self.register_series("current_vsrc") self.register_series("current_hvsrc") self.register_series("bias_voltage") self.register_series("temperature_box") self.register_series("temperature_chuck") self.register_series("humidity_box") # Initialize HV Source self.hvsrc_reset(hvsrc) self.hvsrc_setup(hvsrc) self.hvsrc_set_current_compliance(hvsrc, hvsrc_current_compliance) self.process.emit("state", dict( hvsrc_voltage=self.hvsrc_get_voltage_level(hvsrc), hvsrc_current=None, hvsrc_output=self.hvsrc_get_output_state(hvsrc) )) if not self.process.running: return # Initialize V Source self.vsrc_reset(vsrc) self.vsrc_setup(vsrc) # Voltage source self.vsrc_set_function_voltage(vsrc) self.vsrc_set_current_compliance(vsrc, vsrc_current_compliance) if not self.process.running: return # Initialize Electrometer self.elm_safe_write(elm, "*RST") self.elm_safe_write(elm, "*CLS") # Filter self.elm_safe_write(elm, f":SENS:CURR:AVER:COUN {elm_filter_count:d}") if elm_filter_type == "repeat": self.elm_safe_write(elm, ":SENS:CURR:AVER:TCON REP") elif elm_filter_type == "moving": self.elm_safe_write(elm, ":SENS:CURR:AVER:TCON MOV") if elm_filter_enable: self.elm_safe_write(elm, ":SENS:CURR:AVER:STATE ON") else: self.elm_safe_write(elm, ":SENS:CURR:AVER:STATE OFF") nplc = elm_integration_rate / 10. self.elm_safe_write(elm, f":SENS:CURR:NPLC {nplc:02f}") self.elm_set_zero_check(elm, True) assert self.elm_get_zero_check(elm) == True, "failed to enable zero check" self.elm_safe_write(elm, ":SENS:FUNC 'CURR'") # note the quotes! assert elm.resource.query(":SENS:FUNC?") == '"CURR:DC"', "failed to set sense function to current" self.elm_safe_write(elm, f":SENS:CURR:RANG {elm_current_range:E}") if elm_zero_correction: self.elm_safe_write(elm, ":SYST:ZCOR ON") # perform zero correction # Auto range self.elm_safe_write(elm, f":SENS:CURR:RANG:AUTO {elm_current_autorange_enable:d}") self.elm_safe_write(elm, f":SENS:CURR:RANG:AUTO:LLIM {elm_current_autorange_minimum:E}") self.elm_safe_write(elm, f":SENS:CURR:RANG:AUTO:ULIM {elm_current_autorange_maximum:E}") self.elm_set_zero_check(elm, False) assert self.elm_get_zero_check(elm) == False, "failed to disable zero check" self.process.emit("message", "Ramp to start...") # Output enable self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_ON) time.sleep(.100) self.process.emit("state", dict( hvsrc_output=self.hvsrc_get_output_state(hvsrc) )) self.vsrc_set_output_state(vsrc, vsrc.OUTPUT_ON) time.sleep(.100) self.process.emit("state", dict( vsrc_output=self.vsrc_get_output_state(vsrc) )) # Ramp HV Spource to bias voltage voltage = self.vsrc_get_voltage_level(vsrc) logging.info("V Source ramp to bias voltage: from %E V to %E V with step %E V", voltage, bias_voltage, 1.0) for voltage in comet.Range(voltage, bias_voltage, 1.0): self.process.emit("message", "Ramp to bias... {}".format(format_metric(voltage, "V"))) self.vsrc_set_voltage_level(vsrc, voltage) self.process.emit("state", dict( vsrc_voltage=voltage, )) time.sleep(QUICK_RAMP_DELAY) # Compliance tripped? self.vsrc_check_compliance(vsrc) if not self.process.running: break # Ramp HV Source to start voltage voltage = self.hvsrc_get_voltage_level(hvsrc) logging.info("HV Source ramp to start voltage: from %E V to %E V with step %E V", voltage, voltage_start, 1.0) for voltage in comet.Range(voltage, voltage_start, 1.0): self.process.emit("message", "Ramp to start... {}".format(format_metric(voltage, "V"))) self.hvsrc_set_voltage_level(hvsrc, voltage) self.process.emit("state", dict( hvsrc_voltage=voltage, )) time.sleep(QUICK_RAMP_DELAY) # Compliance tripped? self.hvsrc_check_compliance(hvsrc) if not self.process.running: break self.process.emit("progress", 5, 5)
def measure(self, hvsrc, vsrc): self.process.emit("progress", 1, 2) # Parameters voltage_start = self.get_parameter('voltage_start') voltage_stop = self.get_parameter('voltage_stop') voltage_step = self.get_parameter('voltage_step') waiting_time = self.get_parameter('waiting_time') bias_voltage = self.get_parameter('bias_voltage') bias_mode = self.get_parameter('bias_mode') hvsrc_accept_compliance = self.get_parameter('hvsrc_accept_compliance') vsrc_accept_compliance = self.get_parameter('vsrc_accept_compliance') if not self.process.running: return voltage = self.hvsrc_get_voltage_level(hvsrc) ramp = comet.Range(voltage, voltage_stop, voltage_step) est = Estimate(ramp.count) self.process.emit("progress", *est.progress) t0 = time.time() logger.info( "HV Source ramp to end voltage: from %E V to %E V with step %E V", voltage, ramp.end, ramp.step) for voltage in ramp: self.hvsrc_set_voltage_level(hvsrc, voltage) self.process.emit("state", dict(hvsrc_voltage=voltage, )) # Move bias TODO if bias_mode == "offset": bias_voltage += abs( ramp.step) if ramp.begin <= ramp.end else -abs(ramp.step) self.vsrc_set_voltage_level(vsrc, bias_voltage) self.process.emit("state", dict(vsrc_voltage=bias_voltage, )) time.sleep(waiting_time) dt = time.time() - t0 est.advance() self.process.emit( "message", "{} | HV Source {} | Bias {}".format( format_estimate(est), format_metric(voltage, "V"), format_metric(bias_voltage, "V"))) self.process.emit("progress", *est.progress) self.environment_update() # read V Source vsrc_reading = self.vsrc_read_current(vsrc) self.process.emit("reading", "vsrc", abs(voltage) if ramp.step < 0 else voltage, vsrc_reading) # read HV Source hvsrc_reading = self.hvsrc_read_current(hvsrc) self.process.emit("update") self.process.emit( "state", dict(hvsrc_current=hvsrc_reading, vsrc_current=vsrc_reading)) # Append series data self.append_series( timestamp=dt, voltage=voltage, current_vsrc=vsrc_reading, bias_voltage=bias_voltage, temperature_box=self.environment_temperature_box, temperature_chuck=self.environment_temperature_chuck, humidity_box=self.environment_humidity_box) # Compliance tripped? if hvsrc_accept_compliance: if self.hvsrc_compliance_tripped(hvsrc): logger.info( "HV Source compliance tripped, gracefully stopping measurement." ) break else: self.hvsrc_check_compliance(hvsrc) if vsrc_accept_compliance: if self.vsrc_compliance_tripped(vsrc): logger.info( "V Source compliance tripped, gracefully stopping measurement." ) break else: self.vsrc_check_compliance(vsrc) if not self.process.running: break self.process.emit("progress", 2, 2)
def initialize(self, vsrc): self.process.emit("progress", 0, 5) # Parameters current_start = self.get_parameter('current_start') current_stop = self.get_parameter('current_stop') current_step = self.get_parameter('current_step') waiting_time = self.get_parameter('waiting_time') vsrc_voltage_compliance = self.get_parameter('vsrc_voltage_compliance') vsrc_sense_mode = self.get_parameter('vsrc_sense_mode') vsrc_filter_enable = self.get_parameter('vsrc_filter_enable') vsrc_filter_count = self.get_parameter('vsrc_filter_count') vsrc_filter_type = self.get_parameter('vsrc_filter_type') # Extend meta data self.set_meta("current_start", f"{current_start:G} A") self.set_meta("current_stop", f"{current_stop:G} A") self.set_meta("current_step", f"{current_step:G} A") self.set_meta("waiting_time", f"{waiting_time:G} s") self.set_meta("vsrc_voltage_compliance", f"{vsrc_voltage_compliance:G} V") self.vsrc_update_meta() self.environment_update_meta() # Series units self.set_series_unit("timestamp", "s") self.set_series_unit("current", "A") self.set_series_unit("voltage_vsrc", "V") self.set_series_unit("temperature_box", "degC") self.set_series_unit("temperature_chuck", "degC") self.set_series_unit("humidity_box", "%") # Series self.register_series("timestamp") self.register_series("current") self.register_series("voltage_vsrc") self.register_series("temperature_box") self.register_series("temperature_chuck") self.register_series("humidity_box") self.process.emit( "state", dict(vsrc_voltage=self.vsrc_get_voltage_level(vsrc), vsrc_current=self.vsrc_get_current_level(vsrc), vsrc_output=self.vsrc_get_output_state(vsrc))) # Initialize V Source self.process.emit("progress", 1, 5) self.vsrc_reset(vsrc) self.process.emit("progress", 2, 5) self.vsrc_setup(vsrc) # Current source self.vsrc_set_function_current(vsrc) self.vsrc_set_voltage_compliance(vsrc, vsrc_voltage_compliance) self.process.emit("progress", 3, 5) # Override display self.vsrc_set_display(vsrc, 'voltage') self.vsrc_set_output_state(vsrc, vsrc.OUTPUT_ON) time.sleep(.100) self.process.emit("state", dict(vsrc_output=self.vsrc_get_output_state(vsrc), )) self.process.emit("progress", 4, 5) if self.process.running: current = self.vsrc_get_current_level(vsrc) logging.info( "V Source ramp to start current: from %E A to %E A with step %E A", current, current_start, current_step) for current in comet.Range(current, current_start, current_step): self.process.emit( "message", "Ramp to start... {}".format(format_metric(current, "A"))) self.vsrc_set_current_level(vsrc, current) time.sleep(QUICK_RAMP_DELAY) self.process.emit("state", dict(vsrc_current=current, )) # Compliance tripped? self.vsrc_check_compliance(vsrc) if not self.process.running: break self.process.emit("progress", 5, 5)
def initialize(self, hvsrc, elm): self.process.emit("progress", 0, 5) # Parameters voltage_start = self.get_parameter('voltage_start') voltage_stop = self.get_parameter('voltage_stop') voltage_step = self.get_parameter('voltage_step') waiting_time = self.get_parameter('waiting_time') voltage_step_before = self.get_parameter( 'voltage_step_before') or self.get_parameter('voltage_step') waiting_time_before = self.get_parameter('waiting_time_before') voltage_step_after = self.get_parameter( 'voltage_step_after') or self.get_parameter('voltage_step') waiting_time_after = self.get_parameter('waiting_time_after') waiting_time_start = self.get_parameter('waiting_time_start') waiting_time_end = self.get_parameter('waiting_time_end') hvsrc_current_compliance = self.get_parameter( 'hvsrc_current_compliance') hvsrc_accept_compliance = self.get_parameter('hvsrc_accept_compliance') elm_filter_enable = self.get_parameter('elm_filter_enable') elm_filter_count = self.get_parameter('elm_filter_count') elm_filter_type = self.get_parameter('elm_filter_type') elm_zero_correction = self.get_parameter('elm_zero_correction') elm_integration_rate = self.get_parameter('elm_integration_rate') elm_current_range = self.get_parameter('elm_current_range') elm_current_autorange_enable = self.get_parameter( 'elm_current_autorange_enable') elm_current_autorange_minimum = self.get_parameter( 'elm_current_autorange_minimum') elm_current_autorange_maximum = self.get_parameter( 'elm_current_autorange_maximum') elm_read_timeout = self.get_parameter('elm_read_timeout') # Extend meta data self.set_meta("voltage_start", f"{voltage_start:G} V") self.set_meta("voltage_stop", f"{voltage_stop:G} V") self.set_meta("voltage_step", f"{voltage_step:G} V") self.set_meta("waiting_time", f"{waiting_time:G} s") self.set_meta("voltage_step_before", f"{voltage_step_before:G} V") self.set_meta("waiting_time_before", f"{waiting_time_before:G} s") self.set_meta("voltage_step_after", f"{voltage_step_after:G} V") self.set_meta("waiting_time_after", f"{waiting_time_after:G} s") self.set_meta("waiting_time_start", f"{waiting_time_start:G} s") self.set_meta("waiting_time_end", f"{waiting_time_end:G} s") self.set_meta("hvsrc_current_compliance", f"{hvsrc_current_compliance:G} A") self.set_meta("hvsrc_accept_compliance", hvsrc_accept_compliance) self.hvsrc_update_meta() self.set_meta("elm_filter_enable", elm_filter_enable) self.set_meta("elm_filter_count", elm_filter_count) self.set_meta("elm_filter_type", elm_filter_type) self.set_meta("elm_zero_correction", elm_zero_correction) self.set_meta("elm_integration_rate", elm_integration_rate) self.set_meta("elm_current_range", format(elm_current_range, 'G')) self.set_meta("elm_current_autorange_enable", elm_current_autorange_enable) self.set_meta("elm_current_autorange_minimum", format(elm_current_autorange_minimum, 'G')) self.set_meta("elm_current_autorange_maximum", format(elm_current_autorange_maximum, 'G')) self.set_meta("elm_read_timeout", format(elm_read_timeout, 'G')) self.elm_update_meta() self.environment_update_meta() # Series units self.set_series_unit("timestamp", "s") self.set_series_unit("voltage", "V") self.set_series_unit("current_hvsrc", "A") self.set_series_unit("current_elm", "A") self.set_series_unit("temperature_box", "degC") self.set_series_unit("temperature_chuck", "degC") self.set_series_unit("humidity_box", "%") # Series self.register_series("timestamp") self.register_series("voltage") self.register_series("current_hvsrc") self.register_series("current_elm") self.register_series("temperature_box") self.register_series("temperature_chuck") self.register_series("humidity_box") self.hvsrc_reset(hvsrc) self.hvsrc_setup(hvsrc) self.hvsrc_set_current_compliance(hvsrc, hvsrc_current_compliance) self.process.emit( "state", dict(hvsrc_voltage=self.hvsrc_get_voltage_level(hvsrc), hvsrc_current=None, hvsrc_output=self.hvsrc_get_output_state(hvsrc), elm_current=None)) self.process.emit("progress", 1, 5) # If output disabled voltage = 0 self.hvsrc_set_voltage_level(hvsrc, voltage) self.hvsrc_set_output_state(hvsrc, hvsrc.OUTPUT_ON) time.sleep(.100) self.process.emit( "state", dict(hvsrc_output=self.hvsrc_get_output_state(hvsrc))) self.process.emit("progress", 2, 5) self.elm_safe_write(elm, "*RST") self.elm_safe_write(elm, "*CLS") # Filter self.elm_safe_write(elm, f":SENS:CURR:AVER:COUN {elm_filter_count:d}") if elm_filter_type == "repeat": self.elm_safe_write(elm, ":SENS:CURR:AVER:TCON REP") elif elm_filter_type == "repeat": self.elm_safe_write(elm, ":SENS:CURR:AVER:TCON MOV") if elm_filter_enable: self.elm_safe_write(elm, ":SENS:CURR:AVER:STATE ON") else: self.elm_safe_write(elm, ":SENS:CURR:AVER:STATE OFF") nplc = elm_integration_rate / 10. self.elm_safe_write(elm, f":SENS:CURR:NPLC {nplc:02f}") self.elm_set_zero_check(elm, True) assert self.elm_get_zero_check( elm) == True, "failed to enable zero check" self.elm_safe_write(elm, ":SENS:FUNC 'CURR'") # note the quotes! assert elm.resource.query( ":SENS:FUNC?" ) == '"CURR:DC"', "failed to set sense function to current" self.elm_safe_write(elm, f":SENS:CURR:RANG {elm_current_range:E}") if elm_zero_correction: self.elm_safe_write(elm, ":SYST:ZCOR ON") # perform zero correction # Auto range self.elm_safe_write( elm, f":SENS:CURR:RANG:AUTO {elm_current_autorange_enable:d}") self.elm_safe_write( elm, f":SENS:CURR:RANG:AUTO:LLIM {elm_current_autorange_minimum:E}") self.elm_safe_write( elm, f":SENS:CURR:RANG:AUTO:ULIM {elm_current_autorange_maximum:E}") self.elm_set_zero_check(elm, False) assert self.elm_get_zero_check( elm) == False, "failed to disable zero check" voltage = self.hvsrc_get_voltage_level(hvsrc) logger.info( "HV Source ramp to start voltage: from %E V to %E V with step %E V", voltage, voltage_start, voltage_step_before) for voltage in comet.Range(voltage, voltage_start, voltage_step_before): self.process.emit("message", f"{voltage:.3f} V") self.hvsrc_set_voltage_level(hvsrc, voltage) self.process.emit("state", dict(hvsrc_voltage=voltage, )) time.sleep(waiting_time_before) # Compliance tripped? self.hvsrc_check_compliance(hvsrc) if not self.process.running: break # Waiting time before measurement ramp. self.wait(waiting_time_start) self.process.emit("progress", 3, 5)
def measure(self, lcr): self.process.emit("progress", 1, 2) # Parameters bias_voltage_start = self.get_parameter('bias_voltage_start') bias_voltage_step = self.get_parameter('bias_voltage_step') bias_voltage_stop = self.get_parameter('bias_voltage_stop') waiting_time = self.get_parameter('waiting_time') lcr_soft_filter = self.get_parameter('lcr_soft_filter') # Ramp to start voltage lcr_voltage_level = self.lcr_get_bias_voltage_level(lcr) logging.info( "LCR Meter ramp to start voltage: from %E V to %E V with step %E V", lcr_voltage_level, bias_voltage_start, bias_voltage_step) for voltage in comet.Range(lcr_voltage_level, bias_voltage_start, bias_voltage_step): self.process.emit( "message", "Ramp to start... {}".format(format_metric(voltage, "V"))) self.process.emit("progress", 0, 1) self.lcr_set_bias_voltage_level(lcr, voltage) time.sleep(QUICK_RAMP_DELAY) self.process.emit("state", dict(lcr_voltage=voltage, )) if not self.process.running: break if not self.process.running: return lcr_voltage_level = self.lcr_get_bias_voltage_level(lcr) ramp = comet.Range(lcr_voltage_level, bias_voltage_stop, bias_voltage_step) est = Estimate(ramp.count) self.process.emit("progress", *est.progress) t0 = time.time() lcr.clear() benchmark_step = Benchmark("Single_Step") benchmark_lcr = Benchmark("Read_LCR") benchmark_lcr_source = Benchmark("Read_LCR_Source") benchmark_environ = Benchmark("Read_Environment") logging.info( "LCR Meter ramp to end voltage: from %E V to %E V with step %E V", lcr_voltage_level, ramp.end, ramp.step) for voltage in ramp: with benchmark_step: self.lcr_set_bias_voltage_level(lcr, voltage) # Delay time.sleep(waiting_time) dt = time.time() - t0 est.advance() self.process.emit( "message", "{} | V Source {}".format(format_estimate(est), format_metric(voltage, "V"))) self.process.emit("progress", *est.progress) # read LCR, for CpRp -> prim: Cp, sec: Rp with benchmark_lcr: try: if lcr_soft_filter: lcr_prim, lcr_sec = self.lcr_acquire_filter_reading( lcr) else: lcr_prim, lcr_sec = self.lcr_acquire_reading(lcr) except Exception as exc: raise RuntimeError( f"Failed to read from LCR: {exc}") from exc try: lcr_prim2 = 1.0 / (lcr_prim * lcr_prim) except ZeroDivisionError: lcr_prim2 = 0.0 # read V Source with benchmark_lcr_source: lcr_reading = self.lcr_get_bias_polarity_current_level(lcr) logging.info("LCR reading: %s", format_metric(lcr_reading, "A")) self.process.emit("reading", "lcr", abs(voltage) if ramp.step < 0 else voltage, lcr_prim) self.process.emit("reading", "lcr2", abs(voltage) if ramp.step < 0 else voltage, lcr_prim2) self.process.emit("update") self.process.emit( "state", dict(lcr_voltage=voltage, lcr_current=lcr_reading)) self.environment_update() self.process.emit( "state", dict(env_chuck_temperature=self. environment_temperature_chuck, env_box_temperature=self.environment_temperature_box, env_box_humidity=self.environment_humidity_box)) # Append series data self.append_series( timestamp=dt, voltage_lcr=voltage, current_lcr=lcr_reading, capacitance=lcr_prim, capacitance2=lcr_prim2, resistance=lcr_sec, temperature_box=self.environment_temperature_box, temperature_chuck=self.environment_temperature_chuck, humidity_box=self.environment_humidity_box) if not self.process.running: break logging.info(benchmark_step) logging.info(benchmark_lcr) logging.info(benchmark_lcr_source) logging.info(benchmark_environ)
def initialize(self, lcr): self.process.emit("progress", 1, 6) # Parameters bias_voltage_start = self.get_parameter('bias_voltage_start') bias_voltage_step = self.get_parameter('bias_voltage_step') bias_voltage_stop = self.get_parameter('bias_voltage_stop') waiting_time = self.get_parameter('waiting_time') bias_voltage_step_before = self.get_parameter('bias_voltage_step_before') or self.get_parameter('bias_voltage_step') waiting_time_before = self.get_parameter('waiting_time_before') bias_voltage_step_after = self.get_parameter('bias_voltage_step_after') or self.get_parameter('bias_voltage_step') waiting_time_after = self.get_parameter('waiting_time_after') waiting_time_start = self.get_parameter('waiting_time_start') waiting_time_end = self.get_parameter('waiting_time_end') # Extend meta data self.set_meta("bias_voltage_start", f"{bias_voltage_start:G} V") self.set_meta("bias_voltage_stop", f"{bias_voltage_stop:G} V") self.set_meta("bias_voltage_step", f"{bias_voltage_step:G} V") self.set_meta("waiting_time", f"{waiting_time:G} s") self.set_meta("bias_voltage_step_before", f"{bias_voltage_step_before:G} V") self.set_meta("waiting_time_before", f"{waiting_time_before:G} s") self.set_meta("bias_voltage_step_after", f"{bias_voltage_step_after:G} V") self.set_meta("waiting_time_after", f"{waiting_time_after:G} s") self.set_meta("waiting_time_start", f"{waiting_time_start:G} s") self.set_meta("waiting_time_end", f"{waiting_time_end:G} s") self.lcr_update_meta() self.environment_update_meta() # Series units self.set_series_unit("timestamp", "s") self.set_series_unit("voltage_lcr", "V") self.set_series_unit("current_lcr", "A") self.set_series_unit("capacitance", "F") self.set_series_unit("capacitance2", "1") self.set_series_unit("resistance", "Ohm") self.set_series_unit("temperature_box", "degC") self.set_series_unit("temperature_chuck", "degC") self.set_series_unit("humidity_box", "%") # Series self.register_series("timestamp") self.register_series("voltage_lcr") self.register_series("current_lcr") self.register_series("capacitance") self.register_series("capacitance2") self.register_series("resistance") self.register_series("temperature_box") self.register_series("temperature_chuck") self.register_series("humidity_box") # Initialize LCR self.quick_ramp_zero(lcr) self.lcr_reset(lcr) self.process.emit("progress", 5, 6) self.lcr_setup(lcr) self.process.emit("progress", 6, 6) self.lcr_set_bias_voltage_level(lcr, 0) self.lcr_set_bias_state(lcr, True) self.process.emit("state", dict( lcr_voltage=self.lcr_get_bias_voltage_level(lcr), lcr_output=self.lcr_get_bias_state(lcr), )) # Ramp to start voltage lcr_voltage_level = self.lcr_get_bias_voltage_level(lcr) logger.info("LCR Meter ramp to start voltage: from %E V to %E V with step %E V", lcr_voltage_level, bias_voltage_start, bias_voltage_step_before) for voltage in comet.Range(lcr_voltage_level, bias_voltage_start, bias_voltage_step_before): self.process.emit("message", "Ramp to start... {}".format(format_metric(voltage, "V"))) self.process.emit("progress", 0, 1) self.lcr_set_bias_voltage_level(lcr, voltage) time.sleep(waiting_time_after) self.process.emit("state", dict( lcr_voltage=voltage, )) if not self.process.running: break # Waiting time before measurement ramp. self.wait(waiting_time_start)