def run(self):
analyzer = self.app.hardware['auger_electron_analyzer']
from ScopeFoundryHW.ni_daq import NI_AdcTask
import numpy as np
import time
try:
self.app.measurements['auger_spectrum'].setup_analyzer()
time.sleep(3.0) #let electronics settle
self.adc_task = NI_AdcTask('/X-6368/ai4',
range=10.0,
name='adc_monitor',
terminalConfig='default')
#self.adc_task.set_rate(rate=2e6, count=100000, finite=False, clk_source="")
#print("rate", self.adc_task.get_rate())
#self.adc_task.start()
adc_data = np.zeros(65536, dtype=float)
for i in range(65536):
analyzer.analyzer.write_KE_binary(i)
#time.sleep(0.010)
#buf = self.adc_task.read_buffer()
adc_data[i] = self.adc_task.get() #buf.mean()
if i % 64 == 0:
print(i, adc_data[i])
if self.interrupt_measurement_called:
break
finally:
self.adc_task.close()
np.savetxt('outer_vsKEbinary.txt', adc_data)
class AugerElectronAnalyzerViewer(Measurement):
name = 'auger_e_analyzer_view'
def setup(self):
self.ui = load_qt_ui_file(
sibling_path(__file__, "auger_electron_analyzer_viewer.ui"))
self.e_analyzer_hw = self.app.hardware['auger_electron_analyzer']
widget_connections = [
('multiplier', 'multiplier_checkBox'),
('KE', 'KE_doubleSpinBox'),
('pass_energy', 'pass_energy_doubleSpinBox'),
('crr_ratio', 'crr_ratio_doubleSpinBox'),
('resolution', 'resolution_doubleSpinBox'),
('CAE_mode', 'cae_checkBox'),
('quad_X1', 'qX1_doubleSpinBox'),
('quad_Y1', 'qY1_doubleSpinBox'),
('quad_X2', 'qX2_doubleSpinBox'),
('quad_Y2', 'qY2_doubleSpinBox'),
]
for lq_name, widget_name in widget_connections:
lq = self.e_analyzer_hw.settings.get_lq(lq_name)
lq.connect_to_widget(getattr(self.ui, widget_name))
def run(self):
analyzer = self.app.hardware['auger_electron_analyzer']
from ScopeFoundryHW.ni_daq import NI_AdcTask
import numpy as np
import time
try:
self.app.measurements['auger_spectrum'].setup_analyzer()
time.sleep(3.0) #let electronics settle
self.adc_task = NI_AdcTask('/X-6368/ai4',
range=10.0,
name='adc_monitor',
terminalConfig='default')
#self.adc_task.set_rate(rate=2e6, count=100000, finite=False, clk_source="")
#print("rate", self.adc_task.get_rate())
#self.adc_task.start()
adc_data = np.zeros(65536, dtype=float)
for i in range(65536):
analyzer.analyzer.write_KE_binary(i)
#time.sleep(0.010)
#buf = self.adc_task.read_buffer()
adc_data[i] = self.adc_task.get() #buf.mean()
if i % 64 == 0:
print(i, adc_data[i])
if self.interrupt_measurement_called:
break
finally:
self.adc_task.close()
np.savetxt('outer_vsKEbinary.txt', adc_data)
def connect(self):
self.settings.channel.change_readonly(True)
self.adc = NI_AdcTask(channel=self.settings['channel'],
range=10,
name=self.name,
terminalConfig='rse')
self.adc.set_single()
self.adc.start()
#Connect settings to hardware
self.settings.voltage.hardware_read_func = self.read_adc_single
def connect(self):
if self.debug_mode.val:
self.log.debug("connecting to {}".format(self.name))
# Open connection to hardware
self.adc = NI_AdcTask(channel='/Dev1/ai2',
range=10,
name=self.name,
terminalConfig='rse')
self.adc.set_single()
self.adc.start()
#Connect lq to hardware
self.voltage.hardware_read_func = self.read_adc_single
def connect(self):
if self.debug_mode.val: self.log.debug("Connecting to NI_Dac NI_AdcTask")
# Open connection to hardware
if not self.dummy_mode.val:
self.adc = NI_AdcTask('X-6368/ai0:1')
#self.adc_InLens = NI_AdcTask('X-6368/ai1')
#self.adc_SE2 = NI_AdcTask('X-6368/ai0')
else:
if self.debug_mode.val: self.log.debug("Connecting to NI_Dac NI_AdcTask (Dummy Mode)")
# connect logged quantities
self.inLens_signal.hardware_read_func = self.read_inlens_signal
self.se2_signal.hardware_read_func = self.read_se2_signal
class ThorlabsPowerMeterAnalogReadOut(HardwareComponent):
name = 'thorlabs_powermeter_analog_readout'
def setup(self):
self.power = self.add_logged_quantity(name='power',
dtype=float,
si=True,
unit="W",
vmin=0,
vmax=10,
ro=True)
self.voltage = self.add_logged_quantity(name='voltage',
dtype=float,
si=True,
unit="V",
vmin=-10,
vmax=10,
ro=True)
self.power_range = self.add_logged_quantity(name='power_range',
dtype=float,
unit="W",
vmin=0,
vmax=10,
ro=True)
def connect(self):
if self.debug_mode.val:
self.log.debug("connecting to {}".format(self.name))
# Open connection to hardware
self.adc = NI_AdcTask(channel='/Dev1/ai2',
range=10,
name=self.name,
terminalConfig='rse')
self.adc.set_single()
self.adc.start()
#Connect lq to hardware
self.voltage.hardware_read_func = self.read_adc_single
def disconnect(self):
self.settings.disconnect_all_from_hardware()
#disconnect hardware
self.adc.close()
# clean up hardware object
del self.adc
def read_adc_single(self):
resp = self.adc.get()
if self.debug_mode.val:
self.log.debug("read_adc_single resp: {}".format(resp))
return float(resp[0])
class TestAnalogReadOutHW(HardwareComponent):
name = 'test_analog_readout'
def setup(self):
self.settings.New('voltage', dtype=float, ro=True, unit='V')
self.settings.New('channel', dtype=str, initial='/Dev1/ai0')
def connect(self):
self.settings.channel.change_readonly(True)
self.adc = NI_AdcTask(channel=self.settings['channel'],
range=10,
name=self.name,
terminalConfig='rse')
self.adc.set_single()
self.adc.start()
#Connect settings to hardware
self.settings.voltage.hardware_read_func = self.read_adc_single
def disconnect(self):
#disconnect all settings from hardware
for lq in self.settings.as_list():
lq.hardware_read_func = None
lq.hardware_set_func = None
if hasattr(self, 'adc'):
#disconnect hardware
self.adc.stop()
self.adc.close()
# clean up hardware object
del self.adc
self.settings.channel.change_readonly(False)
def read_adc_single(self):
resp = self.adc.get()
if self.debug_mode.val:
self.log.debug("read_adc_single resp: {}".format(resp))
return float(resp[0])
def pre_scan_setup(self):
print("pre_scan_setup auger_quad")
# #### Reset FPGA
self.auger_fpga_hw.setup_single_clock_mode(self.settings['dwell'],
delay_fraction=0.05)
#### setup analyzer
self.analyzer_hw.settings['multiplier'] = True
self.analyzer_hw.settings['CAE_mode'] = self.settings['CAE_mode']
self.analyzer_hw.settings['KE'] = self.settings['ke_start']
self.analyzer_hw.settings['pass_energy'] = self.settings['pass_energy']
self.analyzer_hw.settings['crr_ratio'] = self.settings['crr_ratio']
time.sleep(3.0)
print("pre_scan_setup done auger_quad")
S = self.settings
signal = S['image_signal']
if signal == 1:
self.sem_adc = NI_AdcTask('x-6368/ai1', name='sem')
elif signal == 2:
self.sem_adc = NI_AdcTask('x-6368/ai0', name='sem')
else:
self.sem_adc.close()
self.sem_adc = None
self.ke_array = np.linspace(S['ke_start'], S['ke_end'], S['ke_steps'])
S['n_frames'] = len(self.ke_array)
self.quad_count_map = np.zeros(self.scan_shape, dtype=float)
if S['save_h5']:
self.h5_meas_group['ke_array'] = self.ke_array
self.quad_count_map_h5 = self.create_h5_framed_dataset(
"quad_count_map", self.quad_count_map, dtype=float)
self.quad_max_vs_ke_h5 = self.h5_meas_group.create_dataset(
"quad_max_vs_ke", shape=(S['n_frames'], 3)) # x%, y%, Hz
class SEMDualChanSignal(HardwareComponent):
name = "sem_dualchan_signal"
def setup(self):
# Create logged quantities
self.inLens_signal = self.add_logged_quantity(
name = 'inLens_signal',
initial = 0,
dtype=float, fmt="%e", ro=True,
unit="V",
vmin=-100, vmax=100)
self.se2_signal = self.add_logged_quantity(
name = 'se2_signal',
initial = 0,
dtype=float, fmt="%e", ro=True,
unit="V",
vmin=-100, vmax=100)
self.signal_nsamples = self.add_logged_quantity(
name = 'signal_nsamples',
initial=1,
dtype=int, ro=False,
unit = "",
vmin = 1, vmax=10000)
self.dummy_mode = self.add_logged_quantity(name='dummy_mode', dtype=bool, initial=False, ro=False)
def connect(self):
if self.debug_mode.val: self.log.debug("Connecting to NI_Dac NI_AdcTask")
# Open connection to hardware
if not self.dummy_mode.val:
self.adc = NI_AdcTask('X-6368/ai0:1')
#self.adc_InLens = NI_AdcTask('X-6368/ai1')
#self.adc_SE2 = NI_AdcTask('X-6368/ai0')
else:
if self.debug_mode.val: self.log.debug("Connecting to NI_Dac NI_AdcTask (Dummy Mode)")
# connect logged quantities
self.inLens_signal.hardware_read_func = self.read_inlens_signal
self.se2_signal.hardware_read_func = self.read_se2_signal
def disconnect(self):
#disconnect logged quantities from hardware
self.settings.disconnect_all_from_hardware()
if hasattr(self, 'adc'):
#disconnect hardware
self.adc.close()
#self.adc_InLens.close()
#self.adc_SE2.close()
# clean up hardware object
del self.adc
def read_inlens_signal(self):
return self.read_signals()[1]
def read_se2_signal(self):
return self.read_signals()[0]
def read_signals(self):
t0 = time.time()
if not self.dummy_mode.val:
X = np.zeros(2, dtype=float)
for i in range(self.signal_nsamples.val):
X += self.adc.get()
self.log.debug("read_signals {} sec, nsamples {}".format( time.time() - t0, self.signal_nsamples.val))
return X / self.signal_nsamples.val
else:
time.sleep(self.inLens_signal_nsamples.val * 20e-6)
signal = np.random.random(2)*100.
if self.debug_mode.val:
self.log.debug("{} dummy read_count_rate {}".format(self.name, signal))
return signal
class AugerQuadSlowScan(BaseRaster2DFrameSlowScan):
name = "auger_quad_slowscan"
''' FIX
modified quad scan to do gun align scan, works but slow,
also should detect inlens , not auger, which gives odd effects
probably should duplicate measurement...
Also could use mouse pointer to control stig etc, !
'''
q1 = {
'x_slow': 'quad_X1',
'x_fast': 'X1',
'y_slow': 'quad_Y1',
'y_fast': 'Y1'
}
q2 = {
'x_slow': 'quad_X2',
'x_fast': 'X2',
'y_slow': 'quad_Y2',
'y_fast': 'Y2'
}
xx = {
'x_slow': 'quad_X1',
'x_fast': 'X1',
'y_slow': 'quad_X2',
'y_fast': 'X2'
}
yy = {
'x_slow': 'quad_Y1',
'x_fast': 'Y1',
'y_slow': 'quad_Y2',
'y_fast': 'Y2'
}
scan_mode = [q1, q2, xx, yy]
def scan_specific_setup(self):
self.settings.continuous_scan.update_value(False)
self.settings.continuous_scan.change_readonly(True)
self.settings.n_frames.change_readonly(True)
self.settings.New('quad_scan_mode',
dtype=int,
initial=0,
vmin=0,
vmax=4,
choices=(('quad 1', 0), ('quad 2', 1),
('x shift/angle', 2), ('y shift/angle',
3), ('SEM gun', 4)))
self.settings.New('image_signal',
dtype=int,
initial=0,
vmin=0,
vmax=2,
choices=(('Auger', 0), ('SEM_inlens', 1), ('SEM_SE2',
2)))
self.settings.New('smooth', dtype=bool, initial=True)
#auger analyzer
self.settings.New('Control_KE', dtype=bool, initial=True)
self.settings.New('ke_start',
dtype=float,
initial=30,
unit='V',
vmin=0,
vmax=2200)
self.settings.New('ke_end',
dtype=float,
initial=600,
unit='V',
vmin=1,
vmax=2200)
self.settings.New('ke_steps', dtype=int, initial=10, vmin=1)
self.settings.New('dwell',
dtype=float,
initial=0.05,
unit='s',
si=True,
vmin=1e-4)
self.settings.New('pass_energy',
dtype=float,
initial=50,
unit='V',
vmin=5,
vmax=500)
self.settings.New('crr_ratio',
dtype=float,
initial=5,
vmin=1.5,
vmax=20)
self.settings.New('CAE_mode', dtype=bool, initial=False)
for lqname in ['ke_start', 'ke_end', 'ke_steps', 'dwell']:
self.settings.get_lq(lqname).add_listener(self.compute_times)
self.display_update_period = 0.01
self.auger_fpga_hw = self.app.hardware['auger_fpga']
self.analyzer_hw = self.app.hardware['auger_electron_analyzer']
self.sem_hw = self.app.hardware['sem_remcon']
#raster scan setup
#self.h_unit = self.v_unit = "%"
self.set_h_limits(-100, 100, set_scan_to_max=True)
self.set_v_limits(-100, 100, set_scan_to_max=True)
# begining of run
def pre_scan_setup(self):
print("pre_scan_setup auger_quad")
# #### Reset FPGA
self.auger_fpga_hw.setup_single_clock_mode(self.settings['dwell'],
delay_fraction=0.05)
#### setup analyzer
self.analyzer_hw.settings['multiplier'] = True
self.analyzer_hw.settings['CAE_mode'] = self.settings['CAE_mode']
self.analyzer_hw.settings['KE'] = self.settings['ke_start']
self.analyzer_hw.settings['pass_energy'] = self.settings['pass_energy']
self.analyzer_hw.settings['crr_ratio'] = self.settings['crr_ratio']
time.sleep(3.0)
print("pre_scan_setup done auger_quad")
S = self.settings
signal = S['image_signal']
if signal == 1:
self.sem_adc = NI_AdcTask('x-6368/ai1', name='sem')
elif signal == 2:
self.sem_adc = NI_AdcTask('x-6368/ai0', name='sem')
else:
self.sem_adc.close()
self.sem_adc = None
self.ke_array = np.linspace(S['ke_start'], S['ke_end'], S['ke_steps'])
S['n_frames'] = len(self.ke_array)
self.quad_count_map = np.zeros(self.scan_shape, dtype=float)
if S['save_h5']:
self.h5_meas_group['ke_array'] = self.ke_array
self.quad_count_map_h5 = self.create_h5_framed_dataset(
"quad_count_map", self.quad_count_map, dtype=float)
self.quad_max_vs_ke_h5 = self.h5_meas_group.create_dataset(
"quad_max_vs_ke", shape=(S['n_frames'], 3)) # x%, y%, Hz
def move_position_start(self, x, y):
qmode = self.settings['quad_scan_mode']
if qmode == 4:
self.sem_hw.settings['gun_xy'] = (x, y)
else:
XX = self.scan_mode[qmode]['x_slow']
YY = self.scan_mode[qmode]['y_slow']
self.analyzer_hw.settings[XX] = x
self.analyzer_hw.settings[YY] = y
time.sleep(0.2)
def move_position_slow(self, x, y, dx, dy):
qmode = self.settings['quad_scan_mode']
if qmode == 4:
self.sem_hw.settings['gun_xy'] = (x, y)
else:
XX = self.scan_mode[qmode]['x_slow']
YY = self.scan_mode[qmode]['y_slow']
self.analyzer_hw.settings[XX] = x
self.analyzer_hw.settings[YY] = y
def move_position_fast(self, x, y, dx, dy):
qmode = self.settings['quad_scan_mode']
if qmode == 4:
self.sem_hw.settings['gun_xy'] = (x, y)
else:
self.move_position_slow(x, y, 0, 0)
def on_new_frame(self, frame_i):
print("New frame", frame_i)
if self.settings['Control_KE']:
# set ke
self.analyzer_hw.settings['KE'] = self.ke_array[frame_i]
print("New frame", frame_i, self.analyzer_hw.settings['KE'],
self.ke_array)
# wait
time.sleep(0.1)
def on_end_frame(self, frame_i):
#filter image before finding max
A = self.quad_count_map
if self.settings['smooth']:
B = ndimage.gaussian_filter(A[0, :, :], sigma=2)
else:
B = A[0, :, :]
self.p_max = np.amax(B)
self.p_min = np.amin(B)
self.display_image_map[0, :, :] = B
j, i = np.unravel_index(B.argmax(), B.shape)
k = 0
print("found quad opt peak at ", k, j, i, 'value', A[k, j, i],
'coords', self.h_array[i], self.v_array[j])
#self.move_position_slow(self.h_array[i],self.v_array[j],0,0)
if self.settings['save_h5']:
self.quad_count_map_h5[frame_i, :, :] = A
self.quad_max_vs_ke_h5[
frame_i, :] = self.h_array[i], self.v_array[j], A[k, j, i]
self.current_stage_pos_arrow.setPos(self.h_array[i], self.v_array[j])
def collect_pixel(self, pixel_num, frame_i, k, j, i):
# collect data
if self.settings['image_signal'] == 0:
value = self.auger_fpga_hw.get_single_value(pixel_num == 0)
else:
volts = 0.0
i_ave = 0
while i_ave < 5:
i_ave += 1
volts += self.sem_adc.get()
value = volts / i_ave
self.display_image_map[k, j, i] = value
self.quad_count_map[k, j, i] = value
if pixel_num == 0:
self.p_min = self.p_max = value
else:
self.p_min = min(value, self.p_min)
self.p_max = max(value, self.p_max)
#print(self.name, "collect_pixel", pixel_num, k,j,i, value)
def update_LUT(self):
if False:
self.hist_lut.imageChanged(autoLevel=False)
if hasattr(self, 'p_min'):
self.hist_lut.setLevels(self.p_min, self.p_max)
else:
self.hist_lut.imageChanged(autoLevel=True)
def post_scan_cleanup(self):
self.analyzer_hw.settings['multiplier'] = False
self.sem_adc.close()
class AugerPressureHistory(Measurement):
name = "auger_pressure_history"
def setup(self):
self.has_turbo = 'tc110_turbo' in self.app.hardware
if self.has_turbo:
self.turbo_names = []
for name in ['prep', 'ion', 'nano']:
for x in ['speed', 'power', 'temp']:
self.turbo_names.append(name + "_" + x)
self.settings.New('delta_t',
dtype=float,
unit='s',
vmin=0.0,
initial=1.0)
self.settings.New('save_h5', dtype=bool, initial=True)
#display
self.settings.New('show_last', dtype=int, initial=-1)
self.names = names = ('Prep', 'Nano')
for name in self.names:
self.settings.New(name + "_pressure",
dtype=float,
ro=True,
si=True,
unit="Bar")
#self.settings.New('start_time', dtype=str, ro=True, initial = datestring())
self.settings.New('ADC_channels', dtype=str, initial='9215A/ai0:1')
self.settings.New('TC_channels', dtype=str, initial='cDAQ1-9211/ai0:1')
#setup gui
self.ui = QtWidgets.QWidget()
self.layout = QtWidgets.QHBoxLayout()
self.ui.setLayout(self.layout)
self.control_widget = QtWidgets.QGroupBox(self.name)
self.layout.addWidget(self.control_widget, stretch=0)
self.control_widget.setLayout(QtWidgets.QVBoxLayout())
self.start_button = QtWidgets.QPushButton("Start")
self.control_widget.layout().addWidget(self.start_button)
self.stop_button = QtWidgets.QPushButton("Stop")
self.control_widget.layout().addWidget(self.stop_button)
self.start_button.clicked.connect(self.start)
self.stop_button.clicked.connect(self.interrupt)
self.control_widget.layout().addWidget(\
self.settings.New_UI(exclude=['activation','progress','profile']))
self.control_widget.layout().addWidget(\
self.app.settings.New_UI())
self.graph_layout = pg.GraphicsLayoutWidget(border=(100, 100, 100))
self.layout.addWidget(self.graph_layout, stretch=1)
self.ui.show()
self.ui.setWindowTitle("auger_pressure_history")
self.NUM_CHANS = 2
self.TC_CHAN_NAMES = ['oven_air', 'vac_system']
self.TC_CHANS = 2
self.plots = []
#ion gauge pressure display
axis = DateAxis(orientation='bottom')
self.pressure_plot = plot = self.graph_layout.addPlot(
title="Pressure", axisItems={'bottom': axis})
plot.setLogMode(y=True)
plot.setYRange(-11, -6)
plot.showGrid(y=True, x=True, alpha=1.0)
plot.addLegend()
self.plots.append(plot)
self.pressure_plot_lines = []
for i in range(self.NUM_CHANS):
color = pg.intColor(i)
plot_line = self.pressure_plot.plot(pen=pg.mkPen(color, width=4),
name=names[i],
autoDownsample=True)
self.pressure_plot_lines.append(plot_line)
self.graph_layout.nextRow()
#turbo status display
self.turbo_plot = self.graph_layout.addPlot(title="Turbo",
axisItems={'bottom': axis})
self.turbo_plot.showGrid(y=True, x=True, alpha=1.0)
self.turbo_plot.addLegend()
self.turbo_plot_lines = dict()
for name in self.turbo_names:
if 'prep' in name:
color = 'r'
elif 'ion' in name:
color = 'y'
else:
color = 'w'
if 'speed' in name:
width = 4
style = 1
elif 'power' in name:
style = 2
width = 2
else:
style = style = 3
width = 1
self.turbo_plot_lines[name] = self.turbo_plot.plot(
pen=pg.mkPen(color=color, width=width),
name=name,
autoDownsample=True)
def volts_to_pressure(self, volts):
'''
convert log output of ion gauge into mBarr)
FIX not working for prep ion gauge, vmin or vmax must be wrong...
'''
vmin = np.array([0.0, 0.078])
vmax = np.array([10.0, 2.89])
vhi = np.array([1.0, 1.0])
vlo = np.array([0.0, 0.0])
pmin = np.array([1e-11, 1e-12])
pmax = np.array([1e-2, 0.2])
vr = (volts - vmin) / (vmax - vmin)
vr = np.minimum(1.0, np.maximum(vr, 0.0))
pr = np.log(pmax / pmin)
return pmin * np.exp(vr * pr)
def run(self):
print(self.name, 'run')
#self.settings['start_time'] = self.datestring()
block = self.block = 100
self.chan_history_pressure = np.zeros((self.NUM_CHANS, block),
dtype=float)
#self.chan_history_pressure[:,:] = 1e-11
self.chan_history_time = self.settings['delta_t'] * np.arange(block)
self.history_i = 0
self.display_i = 0
self.press_adc = NI_AdcTask(self.settings['ADC_channels'],
name='pressure')
self.temp_adc = NI_AdcTask(self.settings['TC_channels'],
name='temperature')
self.start_time = time.time()
print(datetime.datetime.now().strftime("%H:%M %b %d, %Y "))
try:
# H5 File
if self.settings['save_h5']:
self.h5file = h5_io.h5_base_file(app=self.app,
measurement=self)
self.h5m = h5_io.h5_create_measurement_group(
measurement=self, h5group=self.h5file)
self.pressure_h5 = self.h5m.create_dataset(
'pressure',
dtype=float,
shape=(self.NUM_CHANS, block),
maxshape=(self.NUM_CHANS, None),
chunks=(self.NUM_CHANS, block))
#self.time_h5 = self.h5m.create_dataset('time', dtype=float, shape=(block,),
# maxshape=(None,), chunks=(block,))
self.epoch_h5 = self.h5m.create_dataset('epoch',
dtype=float,
shape=(block, ),
maxshape=(None, ),
chunks=(block, ))
self.tc_temp_h5 = self.h5m.create_dataset(
'tc_temp',
dtype=float,
shape=(self.TC_CHANS, block),
maxshape=(self.TC_CHANS, None),
chunks=(self.TC_CHANS, block))
print('saving to h5:', self.h5file.filename)
if self.has_turbo:
for name in self.turbo_names:
self.h5m.create_dataset(name,
dtype=float,
shape=(block, ),
maxshape=(None, ),
chunks=(block, ))
while not self.interrupt_measurement_called:
#read ion gauge pressure
volts = 0.0
i_ave = 0
start = time.time()
while (time.time() -
start) < self.settings['delta_t'] or i_ave == 0:
i_ave += 1
volts += self.press_adc.get()
volts /= i_ave
pressure = self.volts_to_pressure(volts)
self.settings['Prep_pressure'] = pressure[0] * 1e-3
self.settings['Nano_pressure'] = pressure[1] * 1e-3
# read tc temperatures
temps = [0, 0] #self.temp_adc.get()
# timestamp
abs_time = time.time()
sample_time = abs_time - self.start_time
# write to numpy arrays
self.chan_history_time = np_block_extend(
self.chan_history_time, self.history_i, block, axis=0)
self.chan_history_time[self.history_i] = sample_time
self.chan_history_pressure = np_block_extend(
self.chan_history_pressure, self.history_i, block, axis=1)
self.chan_history_pressure[:, self.history_i] = pressure
# write to h5
if self.settings['save_h5']:
#h5_resize_and_insert(self.time_h5, self.history_i,
# data=sample_time, block=block, axis=0)
h5_resize_and_insert(self.epoch_h5,
self.history_i,
data=abs_time,
block=block,
axis=0)
h5_resize_and_insert(self.pressure_h5,
self.history_i,
data=pressure[:],
block=block,
axis=1)
h5_resize_and_insert(self.tc_temp_h5,
self.history_i,
data=temps,
block=block,
axis=1)
if self.has_turbo:
for name in self.turbo_names:
val = self.app.hardware[
'tc110_turbo'].settings.get_lq(
name).read_from_hardware()
h5_resize_and_insert(self.h5m[name],
self.history_i,
data=val,
block=block,
axis=0)
#print(volts, self.chan_history_pressure.shape)
self.history_i += 1
finally:
self.h5file.close()
self.press_adc.close()
self.temp_adc.close()
del self.press_adc
del self.temp_adc
print(self.name, 'stopped')
def update_display(self):
if self.history_i > self.display_i:
jj1 = self.history_i
show_last = self.settings['show_last']
if show_last < 0:
jj0 = 0
else:
jj0 = max(0, jj1 - show_last)
#pressure
for i in range(self.NUM_CHANS):
self.pressure_plot_lines[i].setData(
self.epoch_h5[jj0:jj1],
self.chan_history_pressure[i, jj0:jj1])
#Turbo
for name in self.turbo_names:
yy = np.array(self.h5m[name][jj0:jj1], dtype=float)
if 'speed' in name: #convert to %
if 'ion' in name:
yy /= 15.
else:
yy /= 10.
self.turbo_plot_lines[name].setData(self.epoch_h5[jj0:jj1], yy)
self.display_i = self.history_i
def run(self):
print(self.name, 'run')
#self.settings['start_time'] = self.datestring()
block = self.block = 100
self.chan_history_pressure = np.zeros((self.NUM_CHANS, block),
dtype=float)
#self.chan_history_pressure[:,:] = 1e-11
self.chan_history_time = self.settings['delta_t'] * np.arange(block)
self.history_i = 0
self.display_i = 0
self.press_adc = NI_AdcTask(self.settings['ADC_channels'],
name='pressure')
self.temp_adc = NI_AdcTask(self.settings['TC_channels'],
name='temperature')
self.start_time = time.time()
print(datetime.datetime.now().strftime("%H:%M %b %d, %Y "))
try:
# H5 File
if self.settings['save_h5']:
self.h5file = h5_io.h5_base_file(app=self.app,
measurement=self)
self.h5m = h5_io.h5_create_measurement_group(
measurement=self, h5group=self.h5file)
self.pressure_h5 = self.h5m.create_dataset(
'pressure',
dtype=float,
shape=(self.NUM_CHANS, block),
maxshape=(self.NUM_CHANS, None),
chunks=(self.NUM_CHANS, block))
#self.time_h5 = self.h5m.create_dataset('time', dtype=float, shape=(block,),
# maxshape=(None,), chunks=(block,))
self.epoch_h5 = self.h5m.create_dataset('epoch',
dtype=float,
shape=(block, ),
maxshape=(None, ),
chunks=(block, ))
self.tc_temp_h5 = self.h5m.create_dataset(
'tc_temp',
dtype=float,
shape=(self.TC_CHANS, block),
maxshape=(self.TC_CHANS, None),
chunks=(self.TC_CHANS, block))
print('saving to h5:', self.h5file.filename)
if self.has_turbo:
for name in self.turbo_names:
self.h5m.create_dataset(name,
dtype=float,
shape=(block, ),
maxshape=(None, ),
chunks=(block, ))
while not self.interrupt_measurement_called:
#read ion gauge pressure
volts = 0.0
i_ave = 0
start = time.time()
while (time.time() -
start) < self.settings['delta_t'] or i_ave == 0:
i_ave += 1
volts += self.press_adc.get()
volts /= i_ave
pressure = self.volts_to_pressure(volts)
self.settings['Prep_pressure'] = pressure[0] * 1e-3
self.settings['Nano_pressure'] = pressure[1] * 1e-3
# read tc temperatures
temps = [0, 0] #self.temp_adc.get()
# timestamp
abs_time = time.time()
sample_time = abs_time - self.start_time
# write to numpy arrays
self.chan_history_time = np_block_extend(
self.chan_history_time, self.history_i, block, axis=0)
self.chan_history_time[self.history_i] = sample_time
self.chan_history_pressure = np_block_extend(
self.chan_history_pressure, self.history_i, block, axis=1)
self.chan_history_pressure[:, self.history_i] = pressure
# write to h5
if self.settings['save_h5']:
#h5_resize_and_insert(self.time_h5, self.history_i,
# data=sample_time, block=block, axis=0)
h5_resize_and_insert(self.epoch_h5,
self.history_i,
data=abs_time,
block=block,
axis=0)
h5_resize_and_insert(self.pressure_h5,
self.history_i,
data=pressure[:],
block=block,
axis=1)
h5_resize_and_insert(self.tc_temp_h5,
self.history_i,
data=temps,
block=block,
axis=1)
if self.has_turbo:
for name in self.turbo_names:
val = self.app.hardware[
'tc110_turbo'].settings.get_lq(
name).read_from_hardware()
h5_resize_and_insert(self.h5m[name],
self.history_i,
data=val,
block=block,
axis=0)
#print(volts, self.chan_history_pressure.shape)
self.history_i += 1
finally:
self.h5file.close()
self.press_adc.close()
self.temp_adc.close()
del self.press_adc
del self.temp_adc
print(self.name, 'stopped')