def setAcquisitionMode(self, mode):
"""
Set the acquisition mode. The acquisition mode is modified only if it
corresponds to the current used instrument. If success, the parameters
controller is also setup.
Args:
mode (str): aquisition mode name
"""
if ((self.instrument is None) or
(mode not in RundexSettings.ACQUISITION_MODES[self.instrument])):
return
self.rundexFile = None
self.samples = list()
self.acquisitionMode = mode
self.columns = RundexSettings.COLUMNS[self.acquisitionMode]
self.algorithm = RundexSettings.ALGORITHM[self.acquisitionMode]
if self.acquisitionMode in RundexSettings.THREADS_NUMBER:
nThreads = RundexSettings.THREADS_NUMBER[self.acquisitionMode]
else:
nThreads = QThread.idealThreadCount()
self.tasksPool.setMaxThreadCount(nThreads)
self.settings = dict()
self.settings.update(RundexSettings.SETTINGS[self.acquisitionMode])
self._initController()
def setAcquisitionMode(self, mode):
"""
Set the acquisition mode. The acquisition mode is modified only if it
corresponds to the current used instrument. If success, the parameters
controller is also setup.
Args:
mode (str): aquisition mode name
"""
if ((self.instrument is None) or
(mode not in RundexSettings.ACQUISITION_MODES[self.instrument])):
return
self._samples = list()
self._sampleGroups = dict()
self.visualSettings = dict()
if mode in RundexSettings.VISUAL_SETTINGS:
self.visualSettings = RundexSettings.VISUAL_SETTINGS[mode]
self.acquisitionMode = mode
self.algorithm = RundexSettings.ALGORITHM[self.acquisitionMode]
if self.acquisitionMode in RundexSettings.THREADS_NUMBER:
nThreads = RundexSettings.THREADS_NUMBER[self.acquisitionMode]
else:
nThreads = QThread.idealThreadCount()
self.tasksPool.setMaxThreadCount(nThreads)
self.exportModel = DrillExportModel(self.acquisitionMode)
self._initController()
self._initProcessingParameters()
def start(self):
"""Start server and create socket workers."""
self.__logger = logging.getLogger(self.__class__.__name__) # noqa
self.workers = [] # noqa
self.threads = [] # noqa
if not self.cores:
self.cores = QThread.idealThreadCount()
self.close_signal.connect(self.close, Qt.BlockingQueuedConnection)
self.write.connect(self._write)
self.write_all.connect(self._write_all)
self.kick.connect(self._kick)
self.__logger.debug("Allocating {} worker threads...".format(self.cores))
try:
for i in range(self.cores):
self.create_worker()
self.__logger.info("Started worker threads!")
self.__logger.debug("Active socket workers: {}".format(sum([1 for x in self.threads if x.isRunning()])))
self.started.emit()
except Exception as e:
self.__logger.error("Failed to start socket handler: {}".format(e))
self.close()
def __init__(self, app, prefs, parent=None):
super(QVibe, self).__init__(parent)
self.logger = logging.getLogger('qvibe')
self.app = app
self.preferences = prefs
# basic setup and version checking
if getattr(sys, 'frozen', False):
self.__style_path_root = sys._MEIPASS
else:
self.__style_path_root = os.path.dirname(__file__)
self.__version = '0.0.0-alpha.1'
v_path = os.path.abspath(
os.path.join(self.__style_path_root, 'VERSION'))
try:
with open(v_path) as version_file:
self.__version = version_file.read().strip()
except:
logger.exception(f"Unable to read {v_path}")
global_thread_pool = QThreadPool.globalInstance()
global_thread_pool.setMaxThreadCount(QThread.idealThreadCount() + 4)
if self.preferences.get(SYSTEM_CHECK_FOR_UPDATES):
global_thread_pool.start(
VersionChecker(
self.preferences.get(SYSTEM_CHECK_FOR_BETA_UPDATES),
self.__alert_on_old_version,
self.__alert_on_version_check_fail, self.__version))
# UI initialisation
self.setupUi(self)
# run a twisted reactor as its responsiveness is embarrassingly better than QTcpSocket
from twisted.internet import reactor
self.__reactor = reactor
runner = ReactorRunner(self.__reactor)
global_thread_pool.reserveThread()
global_thread_pool.start(runner)
self.app.aboutToQuit.connect(runner.stop)
# core domain stores
self.__timer = None
self.__start_time = None
self.__target_config = self.__load_config()
self.__display_target_config()
self.__measurement_store = MeasurementStore(self.measurementLayout,
self.measurementBox,
self.bufferSize,
self.preferences,
self.__target_config)
self.__measurement_store.signals.data_changed.connect(
self.__display_measurement)
self.__measurement_store.signals.measurement_added.connect(
self.__display_measurement)
self.__measurement_store.signals.visibility_changed.connect(
self.__set_visible_measurements)
self.__recorder_store = RecorderStore(self.__target_config,
self.recordersLayout,
self.centralwidget,
self.__reactor,
self.__measurement_store)
self.__recorder_store.signals.on_status_change.connect(
self.__handle_recorder_connect_event)
target_resolution = f"{self.preferences.get(ANALYSIS_RESOLUTION)} Hz"
self.resolutionHz.setCurrentText(target_resolution)
# menus
self.log_viewer = RollingLogger(self.preferences, parent=self)
self.actionShow_Logs.triggered.connect(self.log_viewer.show_logs)
self.action_Preferences.triggered.connect(self.show_preferences)
self.actionSave_Chart.triggered.connect(self.export_chart)
self.actionExport_Wav.triggered.connect(self.export_wav)
# buffer
self.bufferSize.setValue(self.preferences.get(BUFFER_SIZE))
# magnitude range
self.magMin.setValue(self.preferences.get(CHART_MAG_MIN))
self.magMax.setValue(self.preferences.get(CHART_MAG_MAX))
def keep_min_mag_range():
keep_range(self.magMin, self.magMax, 20)
self.magMin.valueChanged['int'].connect(lambda v: keep_min_mag_range())
self.magMax.valueChanged['int'].connect(lambda v: keep_min_mag_range())
# frequency range
self.freqMin.setValue(self.preferences.get(CHART_FREQ_MIN))
self.freqMax.setValue(self.preferences.get(CHART_FREQ_MAX))
def keep_min_freq_range():
keep_range(self.freqMin, self.freqMax, 20)
self.freqMin.valueChanged['int'].connect(
lambda v: keep_min_freq_range())
self.freqMax.valueChanged['int'].connect(
lambda v: keep_min_freq_range())
# charts
colour_provider = ColourProvider()
self.__analysers = {
0:
Vibration(self.liveVibrationChart, self.preferences,
self.targetSampleRate, self.fps, self.actualFPS,
self.resolutionHz, self.targetAccelSens, self.bufferSize,
self.vibrationAnalysis, self.leftMarker,
self.rightMarker, self.timeRange, self.zoomInButton,
self.zoomOutButton, self.findPeaksButton,
colour_provider),
1:
RTA(self.rtaLayout, self.rtaTab, self.rtaChart, self.preferences,
self.targetSampleRate, self.resolutionHz, self.fps,
self.actualFPS, self.magMin, self.magMax, self.freqMin,
self.freqMax, self.refCurve, self.showValueFor,
self.__measurement_store.signals, colour_provider),
2:
Spectrogram(self.spectrogramView, self.preferences,
self.targetSampleRate, self.fps, self.actualFPS,
self.resolutionHz, self.bufferSize, self.magMin,
self.magMax, self.freqMin, self.freqMax,
self.visibleCurves, self.__measurement_store),
}
self.__start_analysers()
self.set_visible_chart(self.chartTabs.currentIndex())
self.applyTargetButton.setIcon(qta.icon('fa5s.check', color='green'))
self.resetTargetButton.setIcon(qta.icon('fa5s.undo'))
self.visibleCurves.selectAll()
# load saved recorders
saved_recorders = self.preferences.get(RECORDER_SAVED_IPS)
warn_on_no_recorders = False
if saved_recorders is not None:
self.__recorder_store.load(saved_recorders.split('|'))
else:
warn_on_no_recorders = True
# show preferences if we have no IPs
if warn_on_no_recorders is True:
result = QMessageBox.question(
self, 'No Recorders',
f"No qvibe-recorders have been added. \n\nUse the preferences screen to add then.\n\nWould you like to add one now?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if result == QMessageBox.Yes:
self.show_preferences()
self.saveSnapshotButton.setIcon(qta.icon('fa5s.save'))
self.saveSnapshotButton.clicked.connect(self.__save_snapshot)
self.zoomInButton.setIcon(qta.icon('fa5s.compress-arrows-alt'))
self.zoomOutButton.setIcon(qta.icon('fa5s.expand-arrows-alt'))
self.loadMeasurementButton.setIcon(qta.icon('fa5s.folder-open'))
self.actionSave_Signal.triggered.connect(self.__save_signal)
self.actionLoad_Signal.triggered.connect(self.__load_signal)
self.loadMeasurementButton.clicked.connect(self.__load_signal)
self.connectAllButton.clicked.connect(self.__recorder_store.connect)
self.disconnectAllButton.clicked.connect(
self.__recorder_store.disconnect)
self.snapshot_saved.connect(self.__add_snapshot)
self.__measurement_store.load_snapshots()
def accept(self):
'''
Resets the thread pool size back to the default.
'''
self.change_pool_size(QThread.idealThreadCount())
QDialog.accept(self)
