def on_activate(self):
""" Initialisation performed during activation of the module.
"""
self._wavelength_data = []
self.stopRequested = False
self._wavemeter_device = self.get_connector('wavemeter1')
# print("Counting device is", self._counting_device)
self._save_logic = self.get_connector('savelogic')
self._counter_logic = self.get_connector('counterlogic')
# create a new x axis from xmin to xmax with bins points
self.histogram_axis = np.arange(self._xmin, self._xmax,
(self._xmax - self._xmin) / self._bins)
self.histogram = np.zeros(self.histogram_axis.shape)
self.envelope_histogram = np.zeros(self.histogram_axis.shape)
self.sig_update_histogram_next.connect(
self._attach_counts_to_wavelength, QtCore.Qt.QueuedConnection)
# create an indepentent thread for the hardware communication
self.hardware_thread = QtCore.QThread()
# create an object for the hardware communication and let it live on the new thread
self._hardware_pull = HardwarePull(self)
self._hardware_pull.moveToThread(self.hardware_thread)
# connect the signals in and out of the threaded object
self.sig_handle_timer.connect(self._hardware_pull.handle_timer)
# start the event loop for the hardware
self.hardware_thread.start()
self.last_point_time = time.time()
def __init__(self, parent, run, finished=None):
super(Threaded, self).__init__(parent)
# Create thread/objects
self.thread = QtCore.QThread()
worker = Worker(run)
worker.moveToThread(self.thread)
Threaded.add_to_pool(self)
# Connect error reporting
worker.error[str].connect(self.errorString)
# Start up
self.thread.started.connect(worker.process)
# Clean up
worker.finished.connect(self.thread.quit)
worker.finished.connect(worker.deleteLater)
worker.error.connect(self.thread.quit)
worker.error.connect(worker.deleteLater)
self.thread.finished.connect(self.thread.deleteLater)
if finished is not None:
worker.finished.connect(finished)
def remove_ref():
Threaded.remove_from_pool(self)
self.thread.finished.connect(remove_ref)
# Need to keep ref so they stay in mem
self.worker = worker
def __init__(self, config=None):
super().__init__()
self.DELIM = b"<IDS|MSG>"
# namespaces
self.user_global_ns = globals()
self.user_ns = self.user_global_ns
self.exiting = False
self.engine_id = str(uuid.uuid4())
if config is not None:
self.config = config
else:
logging.info("Starting simple_kernel with default args...")
self.config = {
'control_port': 0,
'hb_port': 0,
'iopub_port': 0,
'ip': '127.0.0.1',
'key': str(uuid.uuid4()),
'shell_port': 0,
'signature_scheme': 'hmac-sha256',
'stdin_port': 0,
'transport': 'tcp'
}
self.hb_thread = QtCore.QThread()
self.hb_thread.setObjectName(self.engine_id)
self.connection = config["transport"] + "://" + config["ip"]
self.secure_key = config["key"].encode('ascii')
self.signature_schemes = {"hmac-sha256": hashlib.sha256}
self.auth = hmac.HMAC(
self.secure_key,
digestmod=self.signature_schemes[self.config["signature_scheme"]])
logging.info('New Kernel {}'.format(self.engine_id))
def threadWrapperTearDown(self):
self._thread.wait()
self._thread = QtCore.QThread(self)
self._worker.signals.started.disconnect(self.start_slot)
self._worker.signals.finished.disconnect(self.end_slot)
self._worker.signals.finished.disconnect(self.threadWrapperTearDown)
self._worker.signals.error.disconnect(self.warning)
self.start_slot = lambda: 0
self.end_slot = lambda: 0
def on_activate(self):
#############################################
# Initialisation to access external DLL
#############################################
try:
# imports the spectrometer specific function from dll
self._wavemeterdll = ctypes.windll.LoadLibrary('wlmData.dll')
except:
self.log.critical(
'There is no Wavemeter installed on this '
'Computer.\nPlease install a High Finesse Wavemeter and '
'try again.')
# define the use of the GetWavelength function of the wavemeter
# self._GetWavelength2 = self._wavemeterdll.GetWavelength2
# return data type of the GetWavelength function of the wavemeter
self._wavemeterdll.GetWavelength2.restype = ctypes.c_double
# parameter data type of the GetWavelength function of the wavemeter
self._wavemeterdll.GetWavelength2.argtypes = [ctypes.c_double]
# define the use of the GetWavelength function of the wavemeter
# self._GetWavelength = self._wavemeterdll.GetWavelength
# return data type of the GetWavelength function of the wavemeter
self._wavemeterdll.GetWavelength.restype = ctypes.c_double
# parameter data type of the GetWavelength function of the wavemeter
self._wavemeterdll.GetWavelength.argtypes = [ctypes.c_double]
# define the use of the ConvertUnit function of the wavemeter
# self._ConvertUnit = self._wavemeterdll.ConvertUnit
# return data type of the ConvertUnit function of the wavemeter
self._wavemeterdll.ConvertUnit.restype = ctypes.c_double
# parameter data type of the ConvertUnit function of the wavemeter
self._wavemeterdll.ConvertUnit.argtypes = [
ctypes.c_double, ctypes.c_long, ctypes.c_long
]
# manipulate perdefined operations with simple flags
# self._Operation = self._wavemeterdll.Operation
# return data type of the Operation function of the wavemeter
self._wavemeterdll.Operation.restype = ctypes.c_long
# parameter data type of the Operation function of the wavemeter
self._wavemeterdll.Operation.argtypes = [ctypes.c_ushort]
# create an indepentent thread for the hardware communication
self.hardware_thread = QtCore.QThread()
# create an object for the hardware communication and let it live on the new thread
self._hardware_pull = HardwarePull(self)
self._hardware_pull.moveToThread(self.hardware_thread)
# connect the signals in and out of the threaded object
self.sig_handle_timer.connect(self._hardware_pull.handle_timer)
self._hardware_pull.sig_wavelength.connect(self.handle_wavelength)
# start the event loop for the hardware
self.hardware_thread.start()
def __init__(self, name):
""" Create a ThreadItwm object
@param str name: unique name of the thread
"""
super().__init__()
self.thread = QtCore.QThread()
self.thread.setObjectName(name)
self.name = name
self.thread.finished.connect(self.myThreadHasQuit)
def package_filter_change(self):
try:
if self.comboBox.currentText() == "已安装":
self.package_filter_default()
elif self.comboBox.currentText() == "可更新":
# self.package_filter_update()
self.writing_thread = QtCore.QThread()
self.package_filter_update.moveToThread(self.writing_thread)
except BaseException:
pass
def __init__(self, parent=None):
super(AndorWindow, self).__init__(parent)
self.worker = QtCore.QThread()
self.cam = AndorObject()
self.cam.moveToThread(self.worker)
self.cam.status_changed.connect(self.onCameraStatus)
self.worker.start()
self.setupUi(self)
def __init__(self, parent=None):
super().__init__(parent)
self.optimizationlogic = OptimizationLogic()
# Handle Thread for the optimization
self.thread_optimization = QtCore.QThread(self)
self.optimizationlogic.moveToThread(self.thread_optimization)
self.thread_optimization.start()
self.handle_ui_elements()
self._mw.closeEvent = self.closeEvent
def __init__(self, parent=None):
super().__init__(parent)
self.optimizationlogic = OptimizationLogic()
# Handle Thread for the optimization
self.thread_optimization = QtCore.QThread(self)
self.optimizationlogic.moveToThread(self.thread_optimization)
self.thread_optimization.start()
self.handle_ui_elements()
self._mw.closeEvent = self.closeEvent
# Activate the start button for testing
self._mw.start_optimization_button.setEnabled(True)
def on_activate(self, e):
# create an indepentent thread for the hardware communication
self.hardware_thread = QtCore.QThread()
# create an object for the hardware communication and let it live on the new thread
self._hardware_pull = HardwarePull(self)
self._hardware_pull.moveToThread(self.hardware_thread)
# connect the signals in and out of the threaded object
self.sig_handle_timer.connect(self._hardware_pull.handle_timer)
# start the event loop for the hardware
self.hardware_thread.start()
def __init__(self, model):
super(ThreadModel, self).__init__()
self.model = model
# The ThreadModelWorker wrapping the code to be executed
self._worker = ThreadModelWorker(self.model)
# The QThread instance on which the execution of the code will be performed
self._thread = QtCore.QThread(self)
# callbacks for the .started() and .finished() signals of the worker
self.start_slot = lambda: 0
self.end_slot = lambda: 0
self._exception_callback = self._default_exception_callback
self.check_model_has_correct_attributes()
def start(self):
sys.stdin = self
stdout_fileno = sys.stdout.fileno()
stderr_fileno = sys.stderr.fileno()
stderr_save = os.dup(stderr_fileno)
stdout_save = os.dup(stdout_fileno)
stdout_pipe = os.pipe()
os.dup2(stdout_pipe[1], stdout_fileno)
os.dup2(stdout_pipe[1], stderr_fileno)
os.close(stdout_pipe[1])
self.receiver = Receiver(stdout_pipe[0])
self.receiver.received.connect(self.append_text)
self.stdoutThread = QtCore.QThread()
self.receiver.moveToThread(self.stdoutThread)
self.stdoutThread.started.connect(self.receiver.run)
self.stdoutThread.start()
def toggleStart(self):
if self.start_button.isChecked():
self.start_button.setText('Starting...')
if self.mode == GageMode.TRAD:
self.sample_length = self.length_input.value()
for config in channel_config:
config.segments = []
self._worker = GageTradWorker(self.run_widget)
elif self.mode == GageMode.SEG:
self.sample_length = 0
for config in channel_config:
cw = self.channel_widgets[config.id]
config.segments = cw.get_segments()
seg_ends = [seg[2] for seg in config.segments]
if len(seg_ends) > 0:
self.sample_length = max(self.sample_length, max(seg_ends))
self._worker = GageSegWorker(self.run_widget, self.triggers)
self.sample_depth = int(sample_clk * self.sample_length / 1e3)
for cid, cw in self.channel_widgets.items():
cw._pw.setXRange(0, self.sample_length * 1e-3)
log('Starting acquisition for {:.1f} ms ({:d} samples)'.format(self.sample_length, self.sample_depth))
self._gage_configure()
self._thread = QtCore.QThread()
self._worker.moveToThread(self._thread)
self.capture_acquired.connect(self._worker.process_capture)
self._worker.plot_capture.connect(self._plot_capture)
self._thread.started.connect(self._worker.started)
self._thread.finished.connect(self._thread_finished)
self._thread.start()
self._acquiring = True
self.gage.Start() # Arm acquisition
self.state = GageState.ACQUIRE
else:
self._stop_acquisition()
def __init__(self, long_job_gen):
super(ProgressingWindow, self).__init__()
qbtn = qtw.QDialogButtonBox.Ok | qtw.QDialogButtonBox.Cancel
self.buttonbox = qtw.QDialogButtonBox(qbtn)
self.buttonbox.accepted.connect(self.accept)
self.buttonbox.rejected.connect(self.reject)
self.long_job_gen = long_job_gen
form = qtw.QWidget()
self.setWindowTitle("Background Running Jobs")
layout = qtw.QFormLayout()
form.setLayout(layout)
self.run_btn = qtw.QPushButton('Clear Contents',
clicked=self.clear_running)
self.run_btn.animateClick()
self.progress_bar = qtw.QProgressBar(self)
self.results = qtw.QTableWidget(0, 2)
self.results.setHorizontalHeaderLabels(['percentage', 'content'])
self.results.horizontalHeader().setSectionResizeMode(
qtw.QHeaderView.Stretch)
self.results.setSizePolicy(qtw.QSizePolicy.Expanding,
qtw.QSizePolicy.Expanding)
layout.addRow(qtw.QLabel("Job running status"))
layout.addRow(self.progress_bar)
layout.addRow('Clear button', self.run_btn)
layout.addRow(self.results)
layout.addRow(self.buttonbox)
self.runner = Runner(self.long_job_gen)
self.runner_thread = qtc.QThread()
self.runner.running.connect(self.add_job_to_table)
self.runner.running.connect(self.progress_bar.setValue)
self.running_submitted.connect(self.runner.run)
self.runner.moveToThread(self.runner_thread)
self.runner_thread.start(priority=qtc.QThread.IdlePriority)
self.setLayout(layout)
self.show()
def start_worker(self):
"""
Start a thread to periodically update readings.
"""
if self.worker and self.thread:
self.worker.running = True
else:
self.dialog = SensorDialog(self.mercury.modules)
self.dialog.accepted.connect(self.update_modules)
# start data collection thread
self.thread = QtCore.QThread()
self.worker = DataCollectionWorker(self.refresh, self.mercury,
self.dialog.modNumbers)
self.worker.moveToThread(self.thread)
self.worker.readings_signal.connect(self._get_data)
self.worker.connected_signal.connect(self.connected_signal.emit)
self.thread.started.connect(self.worker.run)
self.update_modules(self.dialog.modNumbers)
self.thread.start()
def __init__(self, parent=None):
super().__init__(parent)
self._settings = QtCore.QSettings(QtCore.QSettings.NativeFormat,
QtCore.QSettings.UserScope,
'HF_AIO', 'MemoryUsageMonitor')
self._pid = None
self._ct = ''
self._dq = collections.deque(maxlen=self._settings.value('dq_maxlen', 120, type=int))
self._progress = QtWidgets.QProgressDialog(self)
self._progress.setCancelButton(None)
self._progress.setWindowTitle(__app_tittle__)
self._progress.setWindowModality(QtCore.Qt.WindowModal)
self._progress.setMinimumWidth(300)
self._progress.reset()
self._worker_thread = QtCore.QThread()
self._worker_thread.start()
self._log_parse_runnable = None # type: Union[None, QtCore.QObject]
self._timer = QtCore.QTimer()
self._timer.timeout.connect(self._on_timer)
self._init_ui()
self._setup_shortcuts()
def newWorkerThread(workerClass, *args, **kwargs):
worker = workerClass(*args, **kwargs)
thread = QtCore.QThread()
worker.moveToThread(thread)
# all workers started using this function must implement work() func
thread.started.connect(worker.work)
thread.finished.connect(thread.deleteLater)
# connect dict from calling object to worker signals
worker_connections = kwargs.get("workerConnect", None)
if worker_connections:
[
getattr(worker, key).connect(val)
for key, val in worker_connections.items()
]
# optionally, can supply onfinish callable when thread finishes
if kwargs.get("onfinish", None):
thread.finished.connect(kwargs.get("onfinish"))
if kwargs.get("start", False) is True:
thread.start() # usually need to connect stuff before starting
return worker, thread
def __init__(self,
worker,
*args,
label='',
canceled_callback=None,
finished_callback=None,
**kwargs):
super().__init__(*args, **kwargs)
self.setLabel(QtWidgets.QLabel(label))
self.worker = worker
self.worker.progress.connect(self.setValue)
if canceled_callback:
self.canceled.connect(canceled_callback)
if finished_callback:
self.worker.finished.connect(finished_callback)
self.thread = QtCore.QThread()
self.worker = worker
self.worker.moveToThread(self.thread)
self.thread.started.connect(self.worker.run)
def on_activate(self):
""" Initialisation performed during activation of the module.
"""
self._wavelength_data = []
self.stopRequested = False
self._wavemeter_device = self.get_connector('wavemeter1')
# print("Counting device is", self._counting_device)
self._save_logic = self.get_connector('savelogic')
self._counter_logic = self.get_connector('counterlogic')
self._fit_logic = self.get_connector('fitlogic')
self.fc = self._fit_logic.make_fit_container('Wavemeter counts', '1d')
self.fc.set_units(['Hz', 'c/s'])
if 'fits' in self._statusVariables and isinstance(
self._statusVariables['fits'], dict):
self.fc.load_from_dict(self._statusVariables['fits'])
else:
d1 = OrderedDict()
d1['Lorentzian peak'] = {
'fit_function': 'lorentzian',
'estimator': 'peak'
}
d1['Two Lorentzian peaks'] = {
'fit_function': 'lorentziandouble',
'estimator': 'peak'
}
d1['Two Gaussian peaks'] = {
'fit_function': 'gaussiandouble',
'estimator': 'peak'
}
default_fits = OrderedDict()
default_fits['1d'] = d1
self.fc.load_from_dict(default_fits)
# create a new x axis from xmin to xmax with bins points
self.histogram_axis = np.arange(self._xmin, self._xmax,
(self._xmax - self._xmin) / self._bins)
self.histogram = np.zeros(self.histogram_axis.shape)
self.envelope_histogram = np.zeros(self.histogram_axis.shape)
self.sig_update_histogram_next.connect(
self._attach_counts_to_wavelength, QtCore.Qt.QueuedConnection)
# fit data
self.wlog_fit_x = np.linspace(self._xmin, self._xmax, self._bins * 5)
self.wlog_fit_y = np.zeros(self.wlog_fit_x.shape)
# create an indepentent thread for the hardware communication
self.hardware_thread = QtCore.QThread()
# create an object for the hardware communication and let it live on the new thread
self._hardware_pull = HardwarePull(self)
self._hardware_pull.moveToThread(self.hardware_thread)
# connect the signals in and out of the threaded object
self.sig_handle_timer.connect(self._hardware_pull.handle_timer)
# start the event loop for the hardware
self.hardware_thread.start()
self.last_point_time = time.time()
def __init__(self,
frames,
traps=None,
labels=None,
active_labels=None,
box_dimensions=None,
mode='standard'):
QtWidgets.QWidget.__init__(self)
#be aware that for a lazy design effort some of the properties of the instance of this class, which is possessed by the main 'AnalyserGUI' panel, are set by direct variable assignment within methods of the 'AnalyserGUI' class.
#This is a manifestation of the ability of python class instance properties to be accessed and changed by external functions. This is not consistently used. Some 'get' and 'set' functions have been written.
#store frames as a dictionary
#this function checks if the input traps and labels are spread over many videos or just one. It sets the structure of the trap position and trap label data stores accordingly and returns either True or False depending on whether there are several videos or just one
self.multividflag = self.checkformultiness(frames, traps, labels,
active_labels)
self.box_dimensions = box_dimensions
self.centres = None
#need to set length of video
self.t0 = 0
self.tmax = 1000
self.mythread = QtCore.QThread()
# initialize single vesicle video as none type
self.vesiclelife = None
# Add deposits for the plotting data for every labelled trap.
self.ydataI = None
self.ydataA = None
#Add deposits for comparing the data to check two different methods of extracting intensity and the area
self.compare_ydataI = None
self.compare_ydataA = None
#Add dictionaries to be passed to the plot function
self.ydata = {}
self.xdata = {}
self.params = {}
self.compare_xdata = {}
self.compare_ydata = {}
self.compare_labels = {}
#Standard message box which prompts user to accept or reject and queued operation
self.interact_display = StandardDialog()
self.proceed_to_directional_query = StandardDialog()
#Add vesicle delete button
self.delete = QtWidgets.QPushButton('Delete Vesicle')
#Add plotting buttons
self.plot_label_btn = QtWidgets.QPushButton('Plot Single Trap')
self.plot_label_btn.clicked.connect(self.plot_now)
#add button to generate heatplot
self.make_heat = QtWidgets.QPushButton('Generate Heat Plot')
self.make_heat.clicked.connect(self.check_then_gen_heat)
#Add button to generate directional heat map. Unless 'directional' mode is turned on this button is not displayed to the user.
self.gen_directional_heatmap_btn = QtWidgets.QPushButton(
'Check Exp Directionality')
self.gen_directional_heatmap_btn.clicked.connect(
self.check_ready_to_record_times)
#switch control for displaying thresholded or unprocessed image inside trap
#abstract switch
self.threshold_on = False
#actual graphic switch
self.threshold_control = QtWidgets.QPushButton(
'Show Thresholded Image')
self.threshold_control.clicked.connect(self.show_thresholded_frame)
#Layout
self.lyt = QtWidgets.QGridLayout()
self.mode_directional_on(mode)
# Widgets
self.label_select_lbl = QtWidgets.QLabel('Select Trap to view')
self.label_select = QtWidgets.QComboBox()
self.video_select = QtWidgets.QComboBox()
#create a subwidget which will be positioned in the layout. Initially for the single video analysis case this will seem redundant as it will just contain a single widget itself. But for the multi video case
#this will also contain a combobox to select which video the vesicle is in
self.combo_container = QtWidgets.QWidget()
container_layout = QtWidgets.QHBoxLayout()
container_layout.addWidget(self.label_select)
self.combo_container.setLayout(container_layout)
if self.labels is not None:
self.label_select.addItems(np.array(self.activelabels).astype(str))
# video viewer
self.one_ves_view = livestream(qnd, images=None, annotations_on=False)
self.go = QtWidgets.QPushButton('Display Trap')
self.warning_box = QtWidgets.QMessageBox()
self.plotter_with_border = PlotBox()
self.go.clicked.connect(self.thread_display_generation)
self.reload_with_centres = QtWidgets.QPushButton(
'Display with \n Detected Centres')
self.reload_with_centres.clicked.connect(self.include_centres)
#include button for saving heat data
self.save_heat = QtWidgets.QPushButton('Save Heat Plot Data')
self.lyt.addWidget(self.label_select_lbl, 2, 0)
self.lyt.addWidget(self.combo_container, 3, 0)
self.lyt.addWidget(self.one_ves_view, 0, 1)
self.lyt.addWidget(self.threshold_control, 1, 1)
self.lyt.addWidget(self.go, 4, 0)
self.lyt.addWidget(self.reload_with_centres, 2, 1)
self.lyt.addWidget(self.plotter_with_border, 0, 0)
self.lyt.addWidget(self.plot_label_btn, 1, 0)
self.lyt.addWidget(self.make_heat, 4, 1)
self.lyt.addWidget(self.save_heat, 5, 1)
self.lyt.addWidget(self.delete, 3, 1)
self.setLayout(self.lyt)
if self.multividflag:
self.addVideoSelector(self.labels_by_vid)
def __init__(self,
labelled_traps,
intensities,
firstintensities,
filtered_intensities,
first_filtered_intensities,
areas,
firstareas,
filtered_areas,
first_filtered_areas,
centres,
firstcentres,
rffitrace,
rffatrace,
t0,
tmax,
save_directory,
vid_id=None,
auto=False):
QWidget.__init__(self)
#Create thread for saving
self.save_thread = QtCore.QThread()
self.auto_save_thread = QtCore.QThread()
#save directory to save files to
self.sd = save_directory
#when autosaving we save the files with an id which matches it to the video file which was analysed to produce the data
self.vid_id = None
#include warning box for errors
self.warning_box = QtWidgets.QMessageBox()
self.labelled_traps = labelled_traps
self.intensities = intensities
self.firstintensities = firstintensities
self.fintensities = filtered_intensities
self.ffintensities = first_filtered_intensities
self.rffitrace = rffitrace
self.areas = areas
self.firstareas = firstareas
self.fareas = filtered_areas
self.ffareas = first_filtered_areas
self.rffatrace = rffatrace
self.centres = centres
self.firstcentres = centres
self.bookends = np.array([t0, tmax])
self.worker = myworker(self.go_on_and_save)
self.autoworker = myworker(self.autosave)
self.save_thread.started.connect(self.worker.run)
self.auto_save_thread.started.connect(self.autoworker.run)
self.worker.sig1.connect(self.save_thread.exit)
self.worker.sig1.connect(self.close)
self.autoworker.sig1.connect(self.auto_save_thread.exit)
self.autoworker.sig1.connect(self.close)
#in order to save as csv file we must make all the numpy arrays the same length
self.save_Date = QtWidgets.QLineEdit('Enter Date, NOT WITH "/"! ')
self.save_Time = QtWidgets.QLineEdit('Enter Time')
self.save_btn = QtWidgets.QPushButton('Save')
self.layout = QtWidgets.QVBoxLayout()
self.layout.addWidget(self.save_Date)
self.layout.addWidget(self.save_Time)
self.setLayout(self.layout)
self.save_Time.returnPressed.connect(self.start_thread)
self.save_btn.clicked.connect(self.start_thread)
self.auto_sig.connect(self.start_auto_thread)
self.vid_id = vid_id
if auto:
self.auto_sig.emit()
def _start_session(self, path=""):
"""
Starts a session.
"""
if self.running:
raise RuntimeError("Must stop session before starting.")
now = datetime.datetime.now()
if not path:
self.output_dir = str(self.ui.lineEdit_output_path.text())
else:
self.output_dir = path
self.ui.lineEdit_output_path.setText(path)
if self.output_dir[-3:] == ".h5":
self.output_dir = self.output_dir[:-3]
if self.ui.checkBox_timestamp.isChecked():
self.output_dir += now.strftime('%y%m%d%H%M%S')
basedir = os.path.dirname(self.output_dir)
try:
os.makedirs(basedir)
except:
pass
device = str(self.ui.comboBox_device.currentText())
data_bits = int(self.ui.lineEdit_data_bits.text())
freq = float(str(self.ui.lineEdit_pulse_freq.text()))
#add in analog recording?
analog_on = self.ui.checkBox_analog_channels.isChecked()
analog_channels = eval(str(self.ui.lineEdit_analog_channels.text()))
analog_sample_rate = float(str(self.ui.comboBox_analog_freq.currentText()))
analog_dtype = int(str(self.ui.comboBox_dtype.currentText()))
#add in counter input?
counter_input_on = self.ui.checkBox_ci.isChecked()
counter_input_terminal = str(self.ui.comboBox_ci.currentText())
# #create Sync object
params = {
'device': device,
'output_dir': self.output_dir,
'event_bits': data_bits,
'freq': freq,
'labels': self.digital_labels,
'analog_on': analog_on,
'analog_channels': analog_channels,
'analog_sample_rate': analog_sample_rate,
'analog_dtype': analog_dtype,
'analog_labels': self.analog_labels,
'counter_input_on': counter_input_on,
'counter_input_terminal': counter_input_terminal,
}
self.sync = SyncObject(params=params)
if self.sync_thread:
self.sync_thread.terminate()
self.sync_thread = QtCore.QThread()
self.sync.moveToThread(self.sync_thread)
self.sync_thread.start()
self.sync_thread.setPriority(QtCore.QThread.TimeCriticalPriority)
QtCore.QTimer.singleShot(100, self.sync.start)
self.write_text("***Starting session at \
%s on %s ***" % (str(now), device))
self.running = True
self._disable_ui()
self._set_visualizer_path(self.output_dir)
self.ui.pushButton_start.setIcon(QtGui.QIcon("res/stop.png"))
def __init__(self, parent):
QtCore.QObject.__init__(self, parent)
self._validation_thread = QtCore.QThread(parent=self)
self._validation_thread.start()
self._validation_worker = None
