def _onTimer(self):
self.last_sample_done = True
d = dict()
values = self.instrument.query_ascii_values('FETC:IMP?')
self.current_bias = float(self.instrument.query('BIAS:VOLT?'))
self.current_frequency = float(self.instrument.query('FREQ?'))
self.current_capacitance = values[0]
measurement_time = time() - self.start_time
d[self.output_channels[0]] = (dict({self.x_units[0] : self.sample_nr,
self.x_units[1] : measurement_time}),
dict({self.y_units[0] : self.current_capacitance,
self.y_units[1] : self.current_frequency,
self.y_units[2] : self.current_bias}))
self.sample_nr += 1
# logger.warning('_onTimer() time: %f, primed timer with: %f, ui: %f, sn: %f',\
# measurement_time,((self.update_interval * float(self.sample_nr)) - measurement_time) * 1000,
# self.update_interval, float(self.sample_nr))
if self.running:
Timer.singleShot(max(0, ((self.update_interval * float(self.sample_nr)) - measurement_time) * 1000), self._onTimer)
self.acquired_data.append(d)
if self.settings_changed:
self.settings_changed = False
self.instrument.write('VOLT ' + str(self.osc_level))
self.instrument.write('BIAS:VOLT ' + str(self.bias))
self.instrument.write('FUNC:IMP ' + str(self.mode))
self.instrument.write('FREQ ' + str(self.frequency))
def _on_timer(self):
socks = dict(self.subscriber_poller.poll(POLL_TIMEOUT))
logger.info(socks)
if self.subscriber in socks and socks[self.subscriber] == zmq.POLLIN:
msg = self.subscriber.recv()
self.connect_timeout = 0
logger.info(msg.decode('UTF8'))
if msg.find('NEWCOL') != -1:
self.current_column = ({self.x_units[0]: 0},
{self.y_units[0]: int(msg.strip('NEWCOL '))})
elif msg.find('STOP') != -1:
if self.control_gasmixer:
if self.active_instrument.running is True:
self.active_instrument.start_stop = True
elif msg.find('START') != -1:
if self.control_gasmixer:
if self.active_instrument.running is False:
self.active_instrument.start_stop = True
else:
self.active_instrument.start_stop = True
self.active_instrument.start_stop = True
logger.info('Starting measurement')
elif msg.find('HEARTBEAT') != -1:
self.state = State.CONNECTED
self.running_label = 'GasMixer ' + State.strings[self.state]
self.timer = Timer.singleShot(0.01, self._on_timer)
return
self.connect_timeout += UPDATE_INTERVAL
if self.connect_timeout > CONNECT_TIMEOUT:
self.state = State.DISCONNECTED
self.running_label = 'GasMixer ' + State.strings[self.state]
self.timer = Timer.singleShot(UPDATE_INTERVAL, self._on_timer)
def start(self):
self.button_label = 'Stop'
self.sample_nr = 1
self.running = True
self.instrument_init()
self.start_time = time()
Timer.singleShot(self.update_interval * 1000 - 200, self._onTimer)
def _on_timer(self):
self.sample_number += 1
data = [self.sample_number, time() - self.start_time]
if self.derivative_resistance_enabled:
self.instrument.write('f2, msg2 = InitiatePulseTest(1)')
response = self.instrument.query('printbuffer(1, {:d}, smua.nvbuffer1)'
.format(self.derivative_resistance_voltage_points))
self.instrument.write('smua.nvbuffer1.clear()')
logger.info(response)
values = [float(n) for n in response.replace(',', '').split()]
filtered_response = savgol_filter(values, self.derivative_resistance_voltage_points, 2, 1,
2*self.derivative_resistance_voltage_span /
(self.derivative_resistance_voltage_points-1))
logger.info(1/filtered_response)
data.append(self.voltage)
data.append(values[self.derivative_resistance_voltage_points/2])
data.append(1/filtered_response[self.derivative_resistance_voltage_points/2])
self.actual_current = values[self.derivative_resistance_voltage_points/2] * 1000
self.actual_voltage = self.voltage
self.dispatch_data(data)
else:
resp = self.instrument.query('print(smua.measure.iv())')
values = [float(f) for f in resp.split()]
data.append(values[1])
data.append(values[0])
data.append(values[1]/values[0])
self.actual_voltage = values[1]
self.actual_current = values[0] * 1000
self.dispatch_data(data)
if self.running:
self.timer = Timer.singleShot(max(((self.sample_number+1) * self.sampling_interval -
(time()-self.start_time))*1000, 0.01),
self._on_timer)
def start(self):
self.running = True
self.acq_start_time = time()
self.sample_nr = 0
self.instrument = SerialUtil.open(self.selected_device, self.visa_resource)
if self.instrument is None:
self.instrument = None
self.selected_device = ''
self.timer = Timer.singleShot(self.sampling_interval * 1000, self.add_data)
def start(self):
self.running = True
self.acq_start_time = time()
self.sample_nr = 0
self.instrument = SerialUtil.open(self.selected_device, self.visa_resource)
self.instrument_init()
if self.instrument is None:
# GenericPopupMessage(message ='Error opening ' + new).edit_traits()
self.instrument = None
self.selected_device = ''
self.timer = Timer.singleShot(self.sampling_interval * 1000, self.add_data)
def _portname_changed(self, new):
if new is '':
return
if self.serialport != None:
self.serialport.close()
try:
self.serialport = serial.Serial(self.portname, 115200, timeout = 0.1)
except Exception as e:
logger.error(e)
return
#self.serialport.open()
self.serialport.flushInput()
self.timer = Timer.singleShot(self.sample_interval, self.add_data)
def __init__(self, **traits):
if USE_ZMQ is False:
return
super(GasMixerPanel, self).__init__(**traits)
self.context = zmq.Context.instance()
self.subscriber = self.context.socket(zmq.SUB)
self.subscriber.connect('tcp://localhost:5561')
self.subscriber.setsockopt(zmq.SUBSCRIBE, "")
self.subscriber_poller = zmq.Poller()
self.subscriber_poller.register(self.subscriber, zmq.POLLIN)
self.state = State.DISCONNECTED
self.timer = Timer.singleShot(UPDATE_INTERVAL, self._on_timer)
def add_data(self):
if not self.running:
return
self.timer = Timer.singleShot(500, self.add_data)
self.response_remainder = self.serial_response[-15:]
self.serial_response = bytearray(self.serialport.inWaiting())
self.serialport.readinto(self.serial_response)
d = self._parse_data(self.response_remainder +self.serial_response)
data_dict = dict()
if self.running is True:
for entry in d:
data_dict[self.output_channels[0]] = entry[0]
data_dict[self.output_channels[1]] = entry[1]
self.acquired_data.append(data_dict)
def start(self):
self.running = True
self.acq_start_time = time()
self.sample_nr = 0
if self.serialport is None:
try:
self.serialport = serial.Serial(self.portname, 57600, timeout = 0.2)
except Exception as e:
logger.error(e)
self.stop()
return
else:
self.serialport.open()
self.serialport.write('a')
self.timer = Timer.singleShot(900, self.add_data)
def add_data(self):
if not self.running:
return
b = bytearray(2)
self.sample_nr += 1
measurement_time = time() - self.acq_start_time
self.serialport.readinto(b)
d = dict()
for i, enabled in enumerate(self.enabled_channels):
d[self.output_channels[i]] = (dict({self.x_units[0]:self.sample_nr,
self.x_units[1]:measurement_time}),\
dict({self.y_units[0]:4.9*((b[0]*256 + b[1])/1024.0)}))
self.timer = Timer.singleShot(max(0, ((float(self.sample_nr)) - measurement_time) * 1000), self.add_data)
self.sensor_output_voltage = 4.9*((b[0]*256 + b[1])/1024.0)
self.acquired_data.append(d)
def start(self):
self.running = True
self.acq_start_time = time()
self.sample_nr = 0
if self.serialport is None:
try:
self.serialport = serial.Serial(self.portname, 115200, timeout=0.045)
except Exception as e:
logger.error(e)
self.stop()
return
else:
self.serialport.open()
self.serial_handler = SerialHandler(self.serialport)
self.serial_handler.start()
self.timer = Timer.singleShot(self.sample_interval * 1000, self.add_data)
def add_data(self):
self.sample_nr += 1
measurement_time = time() - self.acq_start_time
if not self.running:
return
(nox_ppm, lambda_linear, oxygen_millivolt) = self._poll_queue()
self.serial_out = str(nox_ppm)
dict_data = dict()
for i, enabled in enumerate(self.enabled_channels):
dict_data[
self.output_channels[i]] = (
dict(
{self.x_units[0]: self.sample_nr, self.x_units[1]: measurement_time}),
dict({self.y_units[0]: nox_ppm}))
self.acquired_data.append(dict_data)
self.timer = Timer.singleShot(max(0, (self.sample_interval * self.sample_nr -
(time() - self.acq_start_time))*1000), self.add_data)
def add_data(self):
if not self.running:
return
self.sample_nr += 1
try:
data = self.instrument.query('READ?')
except visa.VisaIOError:
data = self.acq_value
pass
self.acq_value = float(data)
logger.info(data)
self.measurement_time = time() - self.acq_start_time
d = dict()
for i, enabled in enumerate(self.enabled_channels):
d[self.output_channels[i]] = (dict({self.x_units[0]:self.sample_nr,
self.x_units[1]:self.measurement_time}),\
self._fix_output_dict(self.acq_value))
self.timer = Timer.singleShot(max(0,
((float(self.sample_nr) * self.sampling_interval) - self.measurement_time) * 1000),
self.add_data)
self.acquired_data.append(d)
def _set_parameters_fired(self):
enter = '\r\n'
if self.serialport.isOpen():
self.serialport.flushOutput()
self.serialport.read(self.serialport.inWaiting())
self.timer = None
self.serialport.write('A')
sleep(0.1)
logger.debug(bytearray(self.serialport.read(self.serialport.inWaiting())))
self.serialport.write(str(self.temperature) + enter)
sleep(0.1)
logger.debug(bytearray(self.serialport.read(self.serialport.inWaiting())))
self.serialport.write(str(0) + enter)
sleep(0.1)
logger.debug(bytearray(self.serialport.read(self.serialport.inWaiting())))
self.serialport.write(str(self.samples_per_sec) + enter)
sleep(0.1)
logger.debug(bytearray(self.serialport.read(self.serialport.inWaiting())))
self.serialport.write(str(self.max_cur_drain1) + enter)
sleep(0.1)
logger.debug(bytearray(self.serialport.read(self.serialport.inWaiting())))
self.serialport.write(str(self.min_cur_drain1) + enter)
sleep(0.1)
logger.debug(bytearray(self.serialport.read(self.serialport.inWaiting())))
self.serialport.write(str(self.max_cur_drain2) + enter)
sleep(0.1)
logger.debug(bytearray(self.serialport.read(self.serialport.inWaiting())))
self.serialport.write(str(self.min_cur_drain2) + enter)
sleep(0.1)
logger.debug(bytearray(self.serialport.read(self.serialport.inWaiting())))
self.serialport.write(str(0) + enter)
sleep(0.1)
# sleep(0.2)
logger.debug(bytearray(self.serialport.read(self.serialport.inWaiting())))
sleep(0.1)
self.serialport.write(enter)
logger.debug(bytearray(self.serialport.read(self.serialport.inWaiting())))
sleep(0.1)
self.timer = Timer.singleShot(500, self.add_data)
def start(self):
self.instrument.write('reset()')
self.instrument.write('digio.writeprotect = 0')
self.instrument.write('smua.measure.nplc = 5')
self.instrument.write('smua.measure.autozero = smua.AUTOZERO_ONCE')
self.instrument.write('smua.sense = smua.SENSE_REMOTE')
self.instrument.write('smua.source.autorangei = smua.AUTORANGE_OFF')
self.instrument.write('smua.source.autorangev = smua.AUTORANGE_OFF')
self.instrument.write('smua.measure.autorangei = smua.AUTORANGE_OFF')
self.instrument.write('smua.measure.autorangev = smua.AUTORANGE_OFF')
if self.constant_current_mode:
self.instrument.write('smua.source.func = smua.OUTPUT_DCAMPS')
self.instrument.write('smua.source.limitv = {:f}'.format(self.voltage_limit))
self.instrument.write('smua.source.leveli = {:f}'.format(self.current/1000))
self.instrument.write('smua.source.rangei = {:f}'.format(1.2*self.current/1000))
if self.voltage_range == 'Auto':
self.instrument.write('smua.measure.autorangev = smua.AUTORANGE_ON')
else:
self.instrument.write('smua.measure.rangev = ' + self.voltage_range)
self.instrument.write('display.smua.measure.func = smua.OUTPUT_DCVOLTS')
else:
self.instrument.write('smua.source.func = smua.OUTPUT_DCVOLTS')
self.instrument.write('smua.source.limiti = {:f}'.format(self.current_limit/1000))
self.instrument.write('smua.source.levelv = {:f}'.format(self.voltage))
self.instrument.write('smua.source.rangev = {:f}'.format(self.voltage*1.2))
if self.current_range == 'Auto':
self.instrument.write('smua.measure.autorangei = smua.AUTORANGE_ON')
else:
self.instrument.write('smua.measure.rangei = {:f}'.format(float(self.current_range)))
self.instrument.write('display.smua.measure.func = smua.OUTPUT_DCAMPS')
if self.derivative_resistance_enabled:
nplc = (0.25*(self.sampling_interval/self.derivative_resistance_voltage_points))/0.02
logger.info('NPLC=%f', nplc)
self.instrument.write('smua.measure.nplc = {:f}'.format(nplc))
self.instrument.write('smua.nvbuffer1.clear()')
self.instrument.write('smua.nvbuffer1.appendmode = 1')
self.instrument.write('smua.source.autorangei = smua.AUTORANGE_OFF')
self.instrument.write('smua.source.autorangev = smua.AUTORANGE_OFF')
self.instrument.write('smua.source.rangev = {:f}'.format(self.voltage +
self.derivative_resistance_voltage_span*1.2))
query = 'f1, msg1 = ConfigPulseVMeasureISweepLin(smua, {:f}, {:f}, {:f}, {:f}, {:f}, 0, {:d}, ' \
'smua.nvbuffer1, 1)'.format(self.voltage,
self.voltage - self.derivative_resistance_voltage_span,
self.voltage + self.derivative_resistance_voltage_span,
self.current_limit/1000,
0.5*(self.sampling_interval /
self.derivative_resistance_voltage_points),
self.derivative_resistance_voltage_points)
logger.info(query)
self.instrument.write(query)
response = self.instrument.query('print(f1, msg1)')
logger.info(response)
self.instrument.write('smua.source.output = smua.OUTPUT_ON')
self.running = True
self.start_time = time()
self.sample_number = 0
if self.running:
self.timer = Timer.singleShot(max(((self.sample_number+1) * self.sampling_interval -
(time()-self.start_time))*1000, 0.01),
self._on_timer)
