def do_refresh(self): try: if self.isVisible(): service_status = agent_status() self.properties.service_status_label.setText(HUMAN_SERVICE_STATUS[service_status]) finally: QTimer.singleShot(REFRESH_PERIOD, self.do_refresh)
class BG7(QThread): def __init__(self, freq, sport='/dev/ttyUSB0'): QThread.__init__(self) self.freq = freq self.timeout_timer = QTimer() self.timeout_timer.setInterval(3000) #self.connect(self.timeout_timer, QtCore.SIGNAL('timeout()'), self.timeout_serial) self.fp = None self.restart = False self.do_debug = False self.sport = sport try: self.reconnect() except Exception as e: print(e) self.empty_buffer() def empty_buffer(self): pass def timeout_serial(self): print('Timeout serial') self.timeout_timer.stop() self.reconnect() self.run() def reconnect(self): if self.fp is not None: try: self.fp.close() except Exception as e: print(e) try: self.fp = serial.Serial(self.sport, 57600, timeout=4) except Exception as e: print(e) raise e def __del__(self): self.wait() def run(self): if self.fp is not None: if self.restart: self.restart = False #self.freq = self.freq while self.fp.inWaiting() > 0: pants = self.fp.read(self.fp.inWaiting()) time.sleep(1.5) print('BG7: trying to empty buff', self.fp.inWaiting()) print('BG7: Finished empty_buffer') print('Sending command', self.freq) self.fp.write('\x8f' + 'f' + format(int(self.freq/10.0), '09'))
def __init__(self): QMainWindow.__init__(self) icons = myIcons() self.getIcon = icons.getIcon self.setWindowTitle('IRAM GUI') self.resize(QSize(1200, 800)) self.setWindowIcon(self.getIcon('Jupiter')) self.measurements = None self.centralwidget = CentralWidget(self) self.setCentralWidget(self.centralwidget) self.HKvalues = self.centralwidget.HKvalues self.Controlvalues = self.centralwidget.Controlvalues self.sBar = self.centralwidget.sBar self.init = False self.running = False self.measureThread = measure(self) self.timer = QTimer() self.timer.timeout.connect(self.updateTimer) self.timer.start(200) self.time = localtime() self.closeEvent = self.closeApp
def do_refresh(self): try: if self.isVisible(): service_status = get_service_status() self.properties.service_status_label.setText(HUMAN_SERVICE_STATUS[service_status]) finally: QTimer.singleShot(REFRESH_PERIOD, self.do_refresh)
def do_refresh(self): try: if self.isVisible(): service_status = get_service_status() self.properties.service_status_label.setText(HUMAN_SERVICE_STATUS[service_status]) if not is_service_stopped(service_status) and self.properties.current_file == self.log_file: self.properties.set_log_file(self.log_file) finally: QTimer.singleShot(REFRESH_PERIOD, self.do_refresh)
class LoggerDialog(QDialog): def __init__(self): QDialog.__init__(self) self.setWindowTitle("Data Logger") self.groupbox1 = DataSetEditGroupBox("Parametres de lock",Loggerdataset,show_button = False) self.groupbox1.dataset.parent = self self.values = self.groupbox1.dataset self.groupbox1.dataset.parent = self lay = QVBoxLayout() lay.addWidget(self.groupbox1) self.setLayout(lay) self.resize(800,300) self.timer = QTimer() self.timer.timeout.connect(self.log) #self.timer.timeout.connect(self.update_values) self.timer.setInterval(100) #ms self.show() def transform_number(self): self.values.next = self.values.next*self.values.mult + self.values.add self.groupbox1.get() def log(self): self.groupbox1.set() if not vsa.on_screen.meas_done(): return if vsa.on_screen.current_average()<self.values.next: vsa.on_screen.resume() return if self.values.save: self.manual() else: vsa.on_screen.resume() self.transform_number() #vsa.on_screen.set_average(self.values.next) def manual(self): vsa.on_screen.pause() try: df = load(self.values.filename) except IOError: df = matched_df() append_one_av(df) df.save(self.values.filename) vsa.on_screen.resume() def start(self): print "starting" vsa.on_screen.set_average(self.values.next) vsa.on_screen.restart() self.timer.start()
def __init__(self): QMainWindow.__init__(self) icons = myIcons() self.getIcon = icons.getIcon self.setWindowTitle('IRAM GUI') self.resize(QSize(1200, 800)) self.setWindowIcon(self.getIcon('Jupiter')) self.measurements = None self.centralwidget = CentralWidget(self) self.setCentralWidget(self.centralwidget) self.HKvalues = self.centralwidget.HKvalues self.Controlvalues = self.centralwidget.Controlvalues self.sBar = self.centralwidget.sBar self.init = False self.running = False try: self.dbr = dbr() self.dbr.init() except: self.dum_dbr = dummy_hardware('DBR') self.dum_dbr.init() try: self.sensors = sensors() self.sensors.init() except: self.dum_HK = dummy_hardware('HOUSEKEEPING') self.dum_HK.init() try: self.chopper = chopper() self.chopper.init() except: self.dum_chop = dummy_hardware('CHOPPER') self.dum_chop.init() self.measureThread = measure(self) self.timer = QTimer() self.timer.timeout.connect(self.updateTimer) self.timer.start(200) self.time = localtime() self.closeEvent = self.closeApp
def start_timed_session_button(self): if not self.timeout: self.sessiontype = 'timed' self.timer.initialize( self.appsettings.dataset.timedsession * 60 ) # the session will start after 'X' seconds X = 20 self.timeout = QTimer( self ) self.connect( self.timeout, SIGNAL( 'timeout()' ), self.session_start ) self.timeout.setSingleShot(True) self.timeout.start(X*1000) self.logmessage('The session will start in %d seconds.' % X) else: # the button is pressed a second time self.timeout.stop() self.timeout = None self.session_start()
def __init__(self, freq, sport='/dev/ttyUSB0'): QThread.__init__(self) self.freq = freq self.timeout_timer = QTimer() self.timeout_timer.setInterval(3000) #self.connect(self.timeout_timer, QtCore.SIGNAL('timeout()'), self.timeout_serial) self.fp = None self.restart = False self.do_debug = False self.sport = sport try: self.reconnect() except Exception, e: print e
def connect_button(self): # The connect button is first trying to open the com port. If the port can be opened, # the zephyr protocol functions are instancied and a message is send to the device # (the thread is started for this purpose and to let the reception of the response). # The device has 3 seconds to respond (a timeout is started to close the serial # and terminate the thread in case of no response). When the device responds a signal 'Message' # is sent to the GUI (the message is the Serial Number of the device). if self.zephyr_connect.connectTo( self.appsettings.dataset.serialport, self.appsettings.dataset.use_virtual_serial): self.zephyr_connect.start() if self.appsettings.dataset.use_virtual_serial is False: self.timeout = QTimer( self ) self.connect( self.timeout, SIGNAL( 'timeout()' ), self.connectionTimeout ) self.timeout.setSingleShot(True) self.timeout.start(3000) else: self.logmessage("Serial virtualization in use.") self._toggle_connect_button() else: self.logmessage( "Fail to open port '%s' !" % self.appsettings.dataset.serialport, 'error' )
def __init__(self, parent): super(controlWidget, self).__init__() self.widgetTimer = QTimer() self.widgetTimer.start(100) self.widgetTimer.timeout.connect(self.createNewDspWidgets) self.value =0 self.flag = True self.mainApp = parent self.inactivityTimeout = True self.setWindowTitle('Live Telemetry Visualizer') self.qbtn = QPushButton('Quit', self) self.qbtn.clicked.connect(self.mainApp.quit) self.qbtn.resize(self.qbtn.sizeHint()) self.qbtn.hide() qbtn1 = QPushButton('Check Performance status') qbtn1.clicked.connect(self.ButtonPressed) qbtn1.resize(qbtn1.sizeHint()) self.performance_status = QLabel("If Performance Curve at Monitor Mic is On turn it Off") self.performance_status.hide() icheck = QCheckBox('Inactivity Timeout') icheck.stateChanged.connect(self.toggleInactivity) icheck.setChecked(self.inactivityTimeout) layout = QVBoxLayout() self.setLayout(layout) layout.addWidget(self.qbtn) layout.addWidget(self.performance_status) layout.addWidget(qbtn1) layout.addWidget(icheck) layout.addWidget(QWidget()) self.resize(180, 100) self.show()
def __init__(self): QMainWindow.__init__(self) icons = myIcons() self.getIcon = icons.getIcon self.setWindowTitle('WVR GUI') self.resize(QSize(1200, 800)) self.setWindowIcon(self.getIcon('spectrum')) self.measurements = None self.centralwidget = CentralWidget(self) self.oem = oemWidget(self.centralwidget.tabs, [21, 23]) self.setCentralWidget(self.centralwidget) self.HKvalues = self.centralwidget.HKvalues self.Controlvalues = self.centralwidget.Controlvalues self.sBar = self.centralwidget.sBar self.init = False self.running = False self.oeminit = False self.oemrunning = False self.oemThread = measure2(self.oem) self.measureThread = measure(self) self.timer = QTimer() self.timer.timeout.connect(self.updateTimer) self.timer.start(200) self.time = localtime() self.closeEvent = self.closeApp self._Tc = 0 self._Th = 0
def __init__(self): QThread.__init__(self) self.running = False self.tsc = TimeSeriesContainer() self.timer = QTimer() self.seconds_elapsed = 0 self.timer.timeout.connect( self.counter_seconds ) self.zephyr_connect = ZephyrDevice() self.zephyr_connect.connectTo(4) self.connect( self.zephyr_connect, SIGNAL( 'Message' ), self.printmessage ) self.connect( self.zephyr_connect, SIGNAL( 'newRRI' ), self.addRR ) self.connect( self.zephyr_connect, SIGNAL( 'newBW' ), self.addBW ) self.connect( self.zephyr_connect, SIGNAL( 'heart_rate' ), self.add_heart_rate ) self.connect( self.zephyr_connect, SIGNAL( 'respiration_rate' ), self.add_respiration_rate ) self.connect( self.zephyr_connect, SIGNAL( 'breathing_wave_amplitude' ), self.add_breathing_wave_amplitude ) self.connect( self.zephyr_connect, SIGNAL( 'activity' ), self.add_activity ) self.connect( self.zephyr_connect, SIGNAL( 'posture' ), self.add_posture ) self.db = influxdb.InfluxDBClient('10.0.0.25', 8086, 'root', 'root', 'rrintervals') self.starttime = time.time()*1000 self.accval = 0
def setup(self, TestGUI): icondir = os.path.dirname(os.path.abspath("__file__")) + "/icons/" icons = [f for f in os.listdir(icondir) if f.find('.png') > -1] self.Icons = {f[0:f.find('.png')]: QIcon(icondir + f) for f in icons} self.setWindowTitle('IRAM GUI') self.resize(QSize(1200, 800)) self.setWindowIcon(self.Icons['Jupiter']) # self.measurements=measurements(sweep=False) self.measurements = None self.mainwidget = CentralWidget(self) self.setCentralWidget(self.mainwidget) self.controlpanel = self.mainwidget.controlpanel self.HKvalues = self.controlpanel.HKvalues self.Controlvalues = self.controlpanel.Controlvalues self.statusbar = self.mainwidget.statusbar self.autoYlim = True self.TestGUI = TestGUI self.init = False self.running = False self.measureThread = measure(self) self.timer = QTimer() self.timer.timeout.connect(self.updateTimer) self.timer.start(100) self.time = localtime() self.closeEvent = self.closeApp
def __init__(self): QDialog.__init__(self) self.setWindowTitle("Data Logger") self.groupbox1 = DataSetEditGroupBox("Parametres de lock",Loggerdataset,show_button = False) self.groupbox1.dataset.parent = self self.values = self.groupbox1.dataset self.groupbox1.dataset.parent = self lay = QVBoxLayout() lay.addWidget(self.groupbox1) self.setLayout(lay) self.resize(800,300) self.timer = QTimer() self.timer.timeout.connect(self.log) #self.timer.timeout.connect(self.update_values) self.timer.setInterval(100) #ms self.show()
class ConnectionThread(QThread): def __init__(self): QThread.__init__(self) self.running = False self.tsc = TimeSeriesContainer() self.timer = QTimer() self.seconds_elapsed = 0 self.timer.timeout.connect( self.counter_seconds ) self.zephyr_connect = ZephyrDevice() self.zephyr_connect.connectTo(4) self.connect( self.zephyr_connect, SIGNAL( 'Message' ), self.printmessage ) self.connect( self.zephyr_connect, SIGNAL( 'newRRI' ), self.addRR ) self.connect( self.zephyr_connect, SIGNAL( 'newBW' ), self.addBW ) self.connect( self.zephyr_connect, SIGNAL( 'heart_rate' ), self.add_heart_rate ) self.connect( self.zephyr_connect, SIGNAL( 'respiration_rate' ), self.add_respiration_rate ) self.connect( self.zephyr_connect, SIGNAL( 'breathing_wave_amplitude' ), self.add_breathing_wave_amplitude ) self.connect( self.zephyr_connect, SIGNAL( 'activity' ), self.add_activity ) self.connect( self.zephyr_connect, SIGNAL( 'posture' ), self.add_posture ) self.db = influxdb.InfluxDBClient('10.0.0.25', 8086, 'root', 'root', 'rrintervals') self.starttime = time.time()*1000 self.accval = 0 def counter_seconds(self): self.seconds_elapsed += 1 def addRR(self, value): self.tsc.ts_rri.add_rrinterval( value ) self.accval += value data = [ { "name": "series2", "columns":["time", "value"], "points":[[self.starttime+self.accval, value]] } ] self.db.write_points_with_precision(data, 'm') print value def addBW(self, value): self.tsc.ts_bw.add_breath( value ) def add_heart_rate(self, value): self.tsc.heart_rate = np.append(self.tsc.heart_rate, value) def add_respiration_rate(self, value): self.tsc.respiration_rate = np.append(self.tsc.respiration_rate, value) def add_breathing_wave_amplitude(self, value): self.tsc.breathwave_ampltitude = np.append(self.tsc.breathwave_ampltitude,value) def add_activity(self, value): self.tsc.activity = np.append(self.tsc.activity, value) def add_posture(self, value): self.tsc.posture = np.append(self.tsc.posture, value) @staticmethod def printmessage( message ): # if isinstance(message, zephyr.message.SummaryMessage): # self.tsc.heart_rate = np.append(self.tsc.heart_rate, message.heart_rate) # self.tsc.respiration_rate = np.append(self.tsc.respiration_rate, message.respiration_rate) # self.tsc.posture = np.append(self.tsc.posture, message.posture) # self.tsc.activity = np.append(self.tsc.activity, message.activity) # self.tsc.breathwave_ampltitude = np.append(self.tsc.breathwave_ampltitude, # message.breathing_wave_amplitude) #print message pass def run(self): self.running = True # self.starttime = datetime.now().strftime("%Y-%m-%d %H:%M:%S") self.zephyr_connect.enablePacket('SUMMARY') self.zephyr_connect.enablePacket('RRDATA') self.zephyr_connect.enablePacket('BREATHING') self.zephyr_connect.start() # while self.running is True: time.sleep(2) def stop(self): self.timer.stop() self.zephyr_connect.disablePacket('SUMMARY') self.zephyr_connect.disablePacket('RRDATA') self.zephyr_connect.disablePacket('BREATHING') self.zephyr_connect.terminate() self.running = False def closeEvent(self, event): QMainWindow.closeEvent(self, event)
class MainWindow(QMainWindow): """Launch the setup and display the interface window .. note:: For more information about the QMainWindow's methods and attributes used here, please refer to the `QMainWindow documentation <http://pyqt.sourceforge.net/Docs/PyQt4/qmainwindow.html>`_ """ def __init__(self): QMainWindow.__init__(self) icons = myIcons() self.getIcon = icons.getIcon self.setWindowTitle('IRAM GUI') self.resize(QSize(1200, 800)) self.setWindowIcon(self.getIcon('Jupiter')) self.measurements = None self.centralwidget = CentralWidget(self) self.setCentralWidget(self.centralwidget) self.HKvalues = self.centralwidget.HKvalues self.Controlvalues = self.centralwidget.Controlvalues self.sBar = self.centralwidget.sBar self.init = False self.running = False try: self.dbr = dbr() self.dbr.init() except: self.dum_dbr = dummy_hardware('DBR') self.dum_dbr.init() try: self.sensors = sensors() self.sensors.init() except: self.dum_HK = dummy_hardware('HOUSEKEEPING') self.dum_HK.init() try: self.chopper = chopper() self.chopper.init() except: self.dum_chop = dummy_hardware('CHOPPER') self.dum_chop.init() self.measureThread = measure(self) self.timer = QTimer() self.timer.timeout.connect(self.updateTimer) self.timer.start(200) self.time = localtime() self.closeEvent = self.closeApp def closeApp(self, *arg): self.sBar.close() self.timer.stop() self.measureThread.close() # configure measurement object def setMeasurement(self): c = self.Controlvalues.getControls() # form={'a':files.aform,'e':files.eform} self.measurements = measurements( # spectrometers=[FW],spectrometer_hosts=['localhost'], # spectrometer_tcp_ports=[25144],spectrometer_udp_ports=[16210], # spectrometer_channels=[[8192,8192]], # formatnames=c.Format,raw_formats=[form[f] for f in c.Format], basename=c.Directory + ('' if c.Directory[-1] is '/' else '/'), sweep=c.Sweep, full_file=c.NSpec, freq=c.Frequency, integration_time=int(c.IntegrationTime * 1000), blank_time=c.BlankTime, antenna_offset=c.Antenna) # init/deinit measurement def measureInitToggle(self): if self.running: self.init = True else: self.init = not self.init if not self.running and self.init: self.measureThread.do('init') else: self.measureThread.do('close') self.sender().setChecked(self.init) self.Controlvalues.setDisabled(self.init) # start/stop measurement def measureStartStop(self): if self.init: self.running = not self.running else: self.running = False if self.running: self.measureThread.do('run') else: self.measureThread.do(None) self.sender().setChecked(self.running) # timer callback function def updateTimer(self): self.timer.stop() self.time = localtime() try: self.HKvalues.updateHK(self.dbr.get_status(), self.Controlvalues) except: self.dum_dbr.run_issue(1.5, 'GET_STATUS') if self.init: self.sBar.setInfo("Initialized", "preview") else: self.sBar.setInfo("Stopped", "stop1") if self.measurements is not None: spec, tabs = self.measurements.spec, self.centralwidget.tabs if tabs.spec != spec: tabs.removeTabs() tabs.setTabs(spec, axisLimits=[0, 2100, 0, 400]) if self.running: self.sBar.setInfo("Running", "preview") try: order = self.measurements.get_order() order = [ order[k] + str(order[0:k].count(w)) for k, w in enumerate(order) ] if len(self.measurements._housekeeping) > 0: chopper_pos = order[len(self.measurements._housekeeping) - 1] Tc, Th = 21., 295. self.centralwidget.tabs.refreshTabs( Tc, Th, order, chopper_pos) except: pass else: self.sBar.setInfo("Stopped", "stop1") self.sBar.refreshInfo() self.timer.start()
class MainWindow(QMainWindow): def __init__(self, TestGUI=True): QMainWindow.__init__(self) self.setup(TestGUI) # ======================================================================= def setup(self, TestGUI): icondir = os.path.dirname(os.path.abspath("__file__")) + "/icons/" icons = [f for f in os.listdir(icondir) if f.find('.png') > -1] self.Icons = {f[0:f.find('.png')]: QIcon(icondir + f) for f in icons} self.setWindowTitle('IRAM GUI') self.resize(QSize(1200, 800)) self.setWindowIcon(self.Icons['Jupiter']) # self.measurements=measurements(sweep=False) self.measurements = None self.mainwidget = CentralWidget(self) self.setCentralWidget(self.mainwidget) self.controlpanel = self.mainwidget.controlpanel self.HKvalues = self.controlpanel.HKvalues self.Controlvalues = self.controlpanel.Controlvalues self.statusbar = self.mainwidget.statusbar self.autoYlim = True self.TestGUI = TestGUI self.init = False self.running = False self.measureThread = measure(self) self.timer = QTimer() self.timer.timeout.connect(self.updateTimer) self.timer.start(100) self.time = localtime() self.closeEvent = self.closeApp # ======================================================================= def closeApp(self, *arg): self.timer.stop() self.measureThread.close() def axisToggle(self): self.autoYlim = not self.autoYlim def resizeAxes(self): return self.autoYlim # ======================================================================= def measureInitToggle(self): if self.running: self.init = True else: self.init = not self.init if not self.running and self.init: self.measureThread.do('init') else: self.measureThread.do('close') self.sender().setChecked(self.init) self.controlpanel.Controlvalues.setDisabled(self.init) # configure measurement object ========================================== def setMeasurement(self): self.Controlvalues.set() c = self.Controlvalues.dataset fnames = ['e', 'a'][c.Format] form = lambda fnames: files.aform if fnames is 'a' else files.eform self.measurements = measurements( # spectrometers=[FW],spectrometer_hosts=['localhost'], # spectrometer_tcp_ports=[25144],spectrometer_udp_ports=[16210], # spectrometer_channels=[[8192, 8192]], formatnames=fnames, raw_formats=[form(f) for f in fnames], basename=c.Directory + ('' if c.Directory[-1] is '/' else '/'), sweep=c.Sweep, full_file=c.NSpec, freq=c.Frequency, integration_time=int(c.IntegrationTime * 1000), blank_time=c.BlankTime, ) # ======================================================================= def measureStartStop(self): if self.init: self.running = not self.running else: self.running = False self.sender().setChecked(self.running) # Save data dialog ====================================================== def saveData(self, *arg): fname = QFileDialog.getSaveFileName(None, u"Save spectra", u"untitled.mat", u"MAT file (*.mat)") if len(fname) == 0: return # self.SIR2.saveData(fname) # Set text information on the panel ===================================== def setActionInfo(self, txt="", icon_name=None): if icon_name is not None: self.mainwidget.ActionIcon.setPixmap(self.Icons[icon_name].pixmap( QSize(16, 16))) self.mainwidget.ActionInfo.setText(txt) self.statusbar.repaint() # Update HK (timer callback) ============================================ def updateHK(self, *arg): hk = self.HKvalues hk.dataset.Band2 = np.random.rand() hk.dataset.Band3 = np.random.rand() hk.dataset.ColdLoad = np.random.rand() hk.get() # Timer callback function =============================================== def updateTimer(self): self.timer.stop() self.time = localtime() self.updateHK() if self.init: self.setActionInfo("Initialized", "preview") else: self.setActionInfo("Stopped", "stop1") if self.running: self.setActionInfo("Running", "preview") x = np.array(range(100)) * 15 - 750. c = self.mainwidget.tabs.sp[0].curves for n in c: for m in c[n]: m.set_data(x, np.random.rand(100)) else: self.setActionInfo("Stopped", "stop1") self.timer.start()
class MainWindow( QMainWindow ): def __init__(self): QMainWindow.__init__(self) self.setWindowTitle(APP_NAME) self.setWindowIcon(get_icon('python.png')) self.timeout = None # used to recognise the checkbox in settings self.bhpacketname = { 'RR':0, 'BREATHING':1, 'ECG':2, 'SUMMARY':3, 'ACC':4, } # Welcome message in statusbar: status = self.statusBar() status.showMessage(_("Zephyr BioHarness 3.0"), 5000) self._setup_layout() self._setup_menu() self._load_settings() self._init_objects() self.show() def _setup_menu(self): # File menu file_menu = self.menuBar().addMenu(_("File")) settings_action = create_action(self, _("Settings"), icon=get_icon('settings.png'), tip=_("Settings"), triggered=self.edit_settings) quit_action = create_action(self, _("Quit"), shortcut="Ctrl+Q", icon=get_std_icon("DialogCloseButton"), tip=_("Quit application"), triggered=self.close) add_actions(file_menu, (settings_action, None, quit_action)) # View menu view_menu = self.createPopupMenu() view_menu.setTitle(_(u"&View")) self.menuBar().addMenu(view_menu) # Help menu help_menu = self.menuBar().addMenu("?") about_action = create_action(self, _("About..."), icon=get_std_icon('MessageBoxInformation'), triggered=self.about) add_actions(help_menu, (about_action,)) # Base toolbar self.connectAction = QAction(QIcon('common/disconnected.png'), 'Connect', self) self.connectAction.triggered.connect( self.connect_button ) self.playAction = QAction(QIcon('common/play.png'), 'Play free', self) self.playAction.triggered.connect( self.start_free_session_button ) self.stopAction = QAction(QIcon('common/stop.png'), 'Stop', self) self.stopAction.triggered.connect( self.stop_button ) self.timedAction = QAction(QIcon('common/timed.png'), 'Start', self) self.timedAction.triggered.connect( self.start_timed_session_button ) self.toolbar = self.addToolBar('Controls') self.toolbar.addAction( self.connectAction ) self.toolbar.addAction( self.playAction ) self.toolbar.addAction( self.stopAction ) self.toolbar.addAction( self.timedAction ) self.toolbar.setObjectName('Controls') # Time toolbar self.timer = Timer( self ) self.connect( self.timer, SIGNAL( 'SessionStop' ), self.session_stop ) def _setup_layout(self): # Allow dockable widgets to be side by side self.setDockOptions(QMainWindow.AnimatedDocks | QMainWindow.AllowNestedDocks) self.setGeometry(300,100,1500,900) self.rrplot = RealTimePlot( self, 'RR-Interval', 'ms', QColor( 255, 0, 0 ) ) self.bwplot = RealTimePlot( self, 'Breathing','', QColor( 0, 0, 255 ) ) self.ecgplot = RealTimePlot( self, 'ECG Waveform','', QColor( 0, 0, 255 ) ) self.logarea = myDockableWidget(self, QTextEdit) self.bwpsd = RealTimePSD( self, 'Breathing PSD', inity=25000 ) self.rrpsd = RealTimePSD( self, 'RR-Interval PSD') self.logarea.widget.setReadOnly( True ) self.logarea.widget.setFont( QFont("Courier", 8) ) self.logarea.widget.setMinimumHeight(150) # Add the DockWidget to the main window self.ecgplot_dock = self.add_dockwidget( self.ecgplot.dockwidget, _("ECG Waveform") ) self.rrcurve_dock = self.add_dockwidget( self.rrplot.dockwidget, _("RR-Intervals Plot") ) self.rrpsd_dock = self.add_dockwidget( self.rrpsd.dockwidget, _("RRI PSD")) self.bwcurve_dock = self.add_dockwidget( self.bwplot.dockwidget, _("Breathing Plot") ) self.bwpsd_dock = self.add_dockwidget( self.bwpsd.dockwidget, _("Breathing PSD (not implemented)") ) self.splitDockWidget(self.rrcurve_dock, self.rrpsd_dock, Qt.Horizontal) self.splitDockWidget(self.bwcurve_dock, self.bwpsd_dock, Qt.Horizontal) self.log_dock = self.add_dockwidget( self.logarea, _("Messages"), position=Qt.BottomDockWidgetArea) #self.splitDockWidget(self.rrcurve_dock, self.ecgplot_dock, Qt.Horizontal) # setting the name of the dock widget is required to save correclty # the postion of the widget when the application close self.rrcurve_dock.setObjectName('rrcurve_dock') self.rrpsd_dock.setObjectName('rrpsd_dock') self.bwcurve_dock.setObjectName('bwcurve_dock') self.bwpsd_dock.setObjectName('bwpsd_dock') self.log_dock.setObjectName('log_dock') self.ecgplot_dock.setObjectName('ecgplot_dock') #self.log_dock.setMinimumHeight( 20 ) self.rrcurve_dock.setMinimumSize( 400, 200 ) self.bwcurve_dock.setMinimumSize( 400, 200 ) self.rrpsd_dock.setMinimumSize( 400, 200 ) self.bwpsd_dock.setMinimumSize( 400, 200 ) self.log_dock.setMinimumSize( 400, 100 ) self.log_dock.setMaximumHeight( 250 ) def _load_settings(self): self.appsettings = DataSetShowGroupBox("Settings", AppSettings, comment='', title=_("Application settings")) self.settings_storage = QSettings('settings.ini', QSettings.IniFormat) self.restoreGeometry( self.settings_storage.value('docksGeometry').toByteArray() ) self.restoreState( self.settings_storage.value('docksState').toByteArray() ) # load settings: self.settings_storage.beginGroup('BioHarnessPackets') rrdata = self.settings_storage.value('rrdata', True).toBool() breathing = self.settings_storage.value('breathing', True).toBool() ecg = self.settings_storage.value('ecg', False).toBool() summary = self.settings_storage.value('summary', False).toBool() accelerometer = self.settings_storage.value('accelerometer', False).toBool() self.settings_storage.endGroup() self.appsettings.dataset.bh_packets = [] if rrdata: self.appsettings.dataset.bh_packets.append(0) if breathing: self.appsettings.dataset.bh_packets.append(1) if ecg: self.appsettings.dataset.bh_packets.append(2) if summary: self.appsettings.dataset.bh_packets.append(3) if accelerometer: self.appsettings.dataset.bh_packets.append(4) self.settings_storage.beginGroup('Misc') self.appsettings.dataset.timedsession = self.settings_storage.value('TimedDuration', 5).toInt()[0] # handle windows and linux serial port name portname = self.settings_storage.value('Serial_Port').toString() if str(portname).isdigit() is True: self.appsettings.dataset.serialport = int(portname) else: self.appsettings.dataset.serialport = str(portname) self.appsettings.dataset.use_virtual_serial = self.settings_storage.value('Use_Virtual_Serial_Port', False).toBool() self.settings_storage.endGroup() self.settings_storage.beginGroup('Storage') self.appsettings.dataset.enable_database = self.settings_storage.value('db_enable', False).toBool() self.appsettings.dataset.db_url = self.settings_storage.value('db_url').toString() self.appsettings.dataset.db_port = self.settings_storage.value('db_port').toString() self.appsettings.dataset.db_user = self.settings_storage.value('db_user').toString() self.appsettings.dataset.db_pwd = self.settings_storage.value('db_pwd').toString() self.appsettings.dataset.db_dbname = self.settings_storage.value('db_dbname').toString() self.appsettings.dataset.enable_files = self.settings_storage.value('files_enable', False).toBool() self.appsettings.dataset.directory_storage = self.settings_storage.value('directory').toString() self.settings_storage.endGroup() def _init_objects(self): # The time series container hold the data of the heart beat and breathing signal self.timeseriescontainer = TimeSeriesContainer() self.sessiontype = 'free' # either free or timed self.zephyr_connect = ZephyrDevice() self.connect( self.zephyr_connect, SIGNAL( 'Message' ), self.printmessage ) self.connect( self.zephyr_connect, SIGNAL( 'rrinterval' ), self.update_RR_plot ) self.connect( self.zephyr_connect, SIGNAL( 'breathing_wave' ), self.update_BW_plot ) self.connect( self.zephyr_connect, SIGNAL( 'ecg' ), self.update_ECG_plot ) self.connect( self.zephyr_connect, SIGNAL( 'heart_rate' ), self.add_heart_rate ) self.connect( self.zephyr_connect, SIGNAL( 'respiration_rate' ), self.add_respiration_rate ) self.connect( self.zephyr_connect, SIGNAL( 'breathing_wave_amplitude' ), self.add_breathing_wave_amplitude ) self.connect( self.zephyr_connect, SIGNAL( 'activity' ), self.add_activity ) self.connect( self.zephyr_connect, SIGNAL( 'posture' ), self.add_posture ) self.zephyr_connect.virtual_serial = self.appsettings.dataset.use_virtual_serial # the button are disabled by default # they are enabled if the connection to the device is successfull self.stopAction.setEnabled( False ) self.playAction.setEnabled( False ) self.timedAction.setEnabled( False ) # InfluxDB storage configuration # Data storage need the application settings for db credentials self.datastorage = DataStorage() if self.appsettings.dataset.enable_database is True: self.datastorage.db_init( self.appsettings.dataset ) self._test_database_connection() # size for the ecg window is different that the default value # of 60' set at the creation of the real time plot self.ecgplot.window_length = 6 def sendbhcmd( self ): cmd = int(str(self.bhcmdinput.text()), 16) self.zephyr_connect.sendmessage(cmd, []) #------? def about( self ): QMessageBox.about( self, _("About ")+APP_NAME, """<b>%s</b> v%s<p>%s Darko Petrovic <br>(Lisence goes here) <p>Python %s, Qt %s, PyQt %s %s %s""" % \ (APP_NAME, VERSION, _("Developped by"), platform.python_version(), QT_VERSION_STR, PYQT_VERSION_STR, _("on"), platform.system()) ) def edit_settings( self ): ok = self.appsettings.dataset.edit() # save settings in the .ini file if ok == 1: # Application settings (window position, view, ...): # ... # User settings: rrdata = breathing = ecg = summary = accelerometer = False for a in self.appsettings.dataset.bh_packets: if a == 0: rrdata = True elif a == 1: breathing = True elif a == 2: ecg = True elif a == 3: summary = True elif a == 4: accelerometer = True self.settings_storage.beginGroup('BioHarnessPackets') self.settings_storage.setValue('rrdata', str(rrdata) ) self.settings_storage.setValue('breathing', str(breathing) ) self.settings_storage.setValue('ecg', str(ecg) ) self.settings_storage.setValue('summary', str(summary) ) self.settings_storage.setValue('accelerometer', str(accelerometer) ) self.settings_storage.endGroup() self.settings_storage.beginGroup('Misc') self.settings_storage.setValue('TimedDuration', self.appsettings.dataset.timedsession ) self.settings_storage.setValue('Serial_Port', self.appsettings.dataset.serialport ) self.settings_storage.setValue('Use_Virtual_Serial_Port', self.appsettings.dataset.use_virtual_serial ) self.settings_storage.endGroup() self.settings_storage.beginGroup('Storage') self.settings_storage.setValue('db_enable', str(self.appsettings.dataset.enable_database) ) self.settings_storage.setValue('db_url', self.appsettings.dataset.db_url ) self.settings_storage.setValue('db_port', self.appsettings.dataset.db_port ) self.settings_storage.setValue('db_user', str(self.appsettings.dataset.db_user) ) self.settings_storage.setValue('db_pwd', str(self.appsettings.dataset.db_pwd) ) self.settings_storage.setValue('db_dbname', str(self.appsettings.dataset.db_dbname) ) self.settings_storage.setValue('files_enable', str(self.appsettings.dataset.enable_files) ) self.settings_storage.setValue('directory', str(self.appsettings.dataset.directory_storage) ) self.settings_storage.endGroup() if ok==1 and self.appsettings.dataset.enable_database: self.datastorage.db_init( self.appsettings.dataset ) self._test_database_connection() if ok==1: self.zephyr_connect.virtual_serial = self.appsettings.dataset.use_virtual_serial def _test_database_connection(self): result, message = self.datastorage.db_connection() if result: self.logmessage(message) else: self.logmessage("Connection to the database failed: %s" % message, 'error') #------GUI refresh/setup def add_dockwidget( self, child, title, orientation = Qt.Vertical, position=None ): """Add a QDockWidget to the main window.""" dockwidget, location = child.create_dockwidget( title ) if position is not None: location = position self.addDockWidget( location, dockwidget, orientation ) return dockwidget def logmessage( self, text, msgtype='info' ): """ Print a message in the message window """ if msgtype == 'error': self.logarea.widget.setTextColor( QColor( 255, 0, 0 ) ) else: self.logarea.widget.setTextColor( QColor( 0, 0, 0 ) ) self.logarea.widget.insertPlainText( text + "\n" ) sb = self.logarea.widget.verticalScrollBar() sb.setValue( sb.maximum() ) def update_RR_plot( self, value ): # Store value in the data-set. We store every value in the dataset # but we display only a certain duration specified by 'self.rrplot.window_length' self.timeseriescontainer.ts_rri.add_rrinterval( value ) if self.appsettings.dataset.enable_database is True: self.datastorage.write_points('rrintervals', value, self.timeseriescontainer.ts_rri.realtime[-1]*1000, 'm') # Set the data to the curve with values from the time series and update the plot self.rrplot.startIdx = self.timeseriescontainer.ts_rri.getSampleIndex( self.rrplot.window_length ) self.rrplot.update( self.timeseriescontainer.ts_rri.realtime, self.timeseriescontainer.ts_rri.series ) # Wait minimum 10 samples if len(self.timeseriescontainer.ts_rri.series) > 10: self.timeseriescontainer.ts_rri.computeLombPeriodogram() self.rrpsd.update(self.timeseriescontainer.ts_rri.psd_freq, self.timeseriescontainer.ts_rri.psd_mag) def update_BW_plot( self, values ): # Store value in the data-set. We store every value in the dataset # but we display only a certain duration specified by 'self.rrplot.window_length' self.timeseriescontainer.ts_bw.add_breath( values ) if self.appsettings.dataset.enable_database is True: self.datastorage.write_points('breathing_wave', values, self.timeseriescontainer.ts_bw.realtime[-len(values):]*1000, 'm') # Set the data to the curve with values from the data-set and update the plot self.bwplot.startIdx = self.timeseriescontainer.ts_bw.getSampleIndex( self.bwplot.window_length ) self.bwplot.update( self.timeseriescontainer.ts_bw.realtime, self.timeseriescontainer.ts_bw.series ) if len(self.timeseriescontainer.ts_bw.series) > 50: # ---- Compute and display the Power Spectral Density of breathing signal self.timeseriescontainer.ts_bw.computeWelchPeriodogram() self.bwpsd.update(self.timeseriescontainer.ts_bw.psd_freq, self.timeseriescontainer.ts_bw.psd_mag) def update_ECG_plot( self, values ): self.timeseriescontainer.ts_ecg.add_ecg( values ) if self.appsettings.dataset.enable_database is True: self.datastorage.write_points('ecg', values, self.timeseriescontainer.ts_ecg.realtime[-len(values):]*1000, 'm') self.ecgplot.startIdx = self.timeseriescontainer.ts_ecg.getSampleIndex( self.ecgplot.window_length ) self.ecgplot.update( self.timeseriescontainer.ts_ecg.realtime, self.timeseriescontainer.ts_ecg.series ) def add_heart_rate(self, value): self.timeseriescontainer.heart_rate = np.append(self.timeseriescontainer.heart_rate, value) if self.appsettings.dataset.enable_database is True: self.datastorage.write_points('heart_rate', value) def add_respiration_rate(self, value): self.timeseriescontainer.respiration_rate = np.append(self.timeseriescontainer.respiration_rate, value) if self.appsettings.dataset.enable_database is True: self.datastorage.write_points('respiration_rate', value) def add_breathing_wave_amplitude(self, value): self.timeseriescontainer.breathwave_ampltitude = np.append(self.timeseriescontainer.breathwave_ampltitude,value) if self.appsettings.dataset.enable_database is True: self.datastorage.write_points('breathing_wave_amplitude', value) def add_activity(self, value): self.timeseriescontainer.activity = np.append(self.timeseriescontainer.activity, value) if self.appsettings.dataset.enable_database is True: self.datastorage.write_points('activity', value) def add_posture(self, value): self.timeseriescontainer.posture = np.append(self.timeseriescontainer.posture, value) if self.appsettings.dataset.enable_database is True: self.datastorage.write_points('posture', value) def printmessage( self, message ): if message == 'connected': self.logmessage( "Successfully connected to the device %s." % self.zephyr_connect.SerialNumber ) self._toggle_connect_button() if self.timeout: self.timeout.stop() self.timeout = None if isinstance(message, zephyr.message.BatteryStatus): self.logmessage("Battery charge is %d%%" % message.Charge ) def _toggle_connect_button(self): if self.zephyr_connect.connected is True: self.connectAction.setIcon(QIcon('common/connected.png')) self.connectAction.setToolTip("Disconnect") self.connectAction.triggered.disconnect( self.connect_button ) self.connectAction.triggered.connect( self.disconnect_button ) self.playAction.setEnabled( True ) self.timedAction.setEnabled( True ) else: self.connectAction.setIcon(QIcon('common/disconnected.png')) self.connectAction.setToolTip("Connect") self.connectAction.triggered.disconnect( self.disconnect_button ) self.connectAction.triggered.connect( self.connect_button ) self.playAction.setEnabled( False ) self.timedAction.setEnabled( False ) def connect_button(self): # The connect button is first trying to open the com port. If the port can be opened, # the zephyr protocol functions are instancied and a message is send to the device # (the thread is started for this purpose and to let the reception of the response). # The device has 3 seconds to respond (a timeout is started to close the serial # and terminate the thread in case of no response). When the device responds a signal 'Message' # is sent to the GUI (the message is the Serial Number of the device). if self.zephyr_connect.connectTo( self.appsettings.dataset.serialport, self.appsettings.dataset.use_virtual_serial): self.zephyr_connect.start() if self.appsettings.dataset.use_virtual_serial is False: self.timeout = QTimer( self ) self.connect( self.timeout, SIGNAL( 'timeout()' ), self.connectionTimeout ) self.timeout.setSingleShot(True) self.timeout.start(3000) else: self.logmessage("Serial virtualization in use.") self._toggle_connect_button() else: self.logmessage( "Fail to open port '%s' !" % self.appsettings.dataset.serialport, 'error' ) def disconnect_button(self): self.zephyr_connect.terminate() if self.zephyr_connect.wait(): self._toggle_connect_button() if self.appsettings.dataset.use_virtual_serial is False: self.logmessage( "Successfully disconnected from the device." ) else: self.logmessage( "Virtual serial stopped." ) def connectionTimeout(self): self.logmessage("Unable to connected to the device on %s." % self.appsettings.dataset.serialport, 'error' ) self.zephyr_connect.terminate() if self.timeout: self.timeout = None def start_free_session_button( self ): self.sessiontype = 'free' self.timer.initialize( 0 ) self.session_start() def start_timed_session_button(self): if not self.timeout: self.sessiontype = 'timed' self.timer.initialize( self.appsettings.dataset.timedsession * 60 ) # the session will start after 'X' seconds X = 20 self.timeout = QTimer( self ) self.connect( self.timeout, SIGNAL( 'timeout()' ), self.session_start ) self.timeout.setSingleShot(True) self.timeout.start(X*1000) self.logmessage('The session will start in %d seconds.' % X) else: # the button is pressed a second time self.timeout.stop() self.timeout = None self.session_start() def stop_button( self ): sel = 0 if self.sessiontype == 'timed': sel = QMessageBox.warning( self, "Timed Session", "A Timed Session is currently active!\nIf you stop the session " "the session will be stored as a free session.", "OK", "Cancel") if sel == 0: self.session_stop() def session_start( self ): if self.timeout: self.timeout.stop() self.timeout = None # empty all arrays self.timeseriescontainer.clearContainer() if self.appsettings.dataset.use_virtual_serial is True: self.zephyr_connect.resume() for a in self.appsettings.dataset.bh_packets: if a == 0: self.zephyr_connect.enablePacket('RRDATA') self.timeseriescontainer.ts_rri.setStartTime() elif a == 1: self.zephyr_connect.enablePacket('BREATHING') self.timeseriescontainer.ts_bw.setStartTime() elif a == 2: self.zephyr_connect.enablePacket('ECG') self.timeseriescontainer.ts_ecg.setStartTime() elif a == 3: self.zephyr_connect.enablePacket('SUMMARY') self.timer.start() # handle graphical change: self.playAction.setEnabled( False ) self.timedAction.setEnabled( False ) self.stopAction.setEnabled( True ) self.connectAction.setEnabled( False ) # in any case, we create the new session in database because the # data are written in real time if self.appsettings.dataset.enable_database is True: self.datastorage.create_session() def session_stop(self): if self.appsettings.dataset.use_virtual_serial is True: self.zephyr_connect.pause() for a in self.appsettings.dataset.bh_packets: if a == 0: self.zephyr_connect.disablePacket('RRDATA') elif a == 1: self.zephyr_connect.disablePacket('BREATHING') elif a == 2: self.zephyr_connect.disablePacket('ECG') elif a == 3: self.zephyr_connect.disablePacket('SUMMARY') self.timer.stop() # handle graphical change: self.playAction.setEnabled( True ) self.timedAction.setEnabled( True ) self.stopAction.setEnabled( False ) self.connectAction.setEnabled( True ) # update session with the duration if self.appsettings.dataset.enable_database is True: self.datastorage.update_duration(self.timer.getRunningTime()) # store more info for the current session? if self.appsettings.dataset.enable_database or self.appsettings.dataset.enable_files: self.infosdialog = SessionInfos( self, self.datastorage ) self.connect(self.infosdialog, SIGNAL('accepted()'), self.add_more_infos ) self.infosdialog.exec_() def add_more_infos(self): sessiontype = 0 for i, r in enumerate(self.infosdialog.sessiontypes): if r.isChecked(): sessiontype = i+1 breathing_zone = self.infosdialog.breathzone.currentIndex() infos = { 'session_type': sessiontype, 'breathing_zone': '' if breathing_zone == 0 else breathing_zone, 'note': str(self.infosdialog.note.toPlainText()), } if self.appsettings.dataset.enable_database is True: self.datastorage.add_informations( infos ) self.logmessage("The information was stored in the database for this session.") def closeEvent(self, event): self.settings_storage.setValue( 'docksGeometry', self.saveGeometry() ) self.settings_storage.setValue( 'docksState', self.saveState() ) QMainWindow.closeEvent(self, event)
class MainWindow(QMainWindow): """Launch the setup and display the interface window .. note:: For more information about the QMainWindow's methods and attributes used here, please refer to the `QMainWindow documentation <http://pyqt.sourceforge.net/Docs/PyQt4/qmainwindow.html>`_ """ def __init__(self): QMainWindow.__init__(self) icons = myIcons() self.getIcon = icons.getIcon self.setWindowTitle('WVR GUI') self.resize(QSize(1200, 800)) self.setWindowIcon(self.getIcon('spectrum')) self.measurements = None self.centralwidget = CentralWidget(self) self.oem = oemWidget(self.centralwidget.tabs, [21, 23]) self.setCentralWidget(self.centralwidget) self.HKvalues = self.centralwidget.HKvalues self.Controlvalues = self.centralwidget.Controlvalues self.sBar = self.centralwidget.sBar self.init = False self.running = False self.oeminit = False self.oemrunning = False self.oemThread = measure2(self.oem) self.measureThread = measure(self) self.timer = QTimer() self.timer.timeout.connect(self.updateTimer) self.timer.start(200) self.time = localtime() self.closeEvent = self.closeApp self._Tc = 0 self._Th = 0 def closeApp(self, *arg): self.sBar.close() self.timer.stop() self.measureThread.close() self.oemThread.close() self.HKvalues.close() # configure measurement object def setMeasurement(self): c = self.Controlvalues.getControls() # form={'a':files.aform,'e':files.eform} self.measurements = measurements( # spectrometers=[FW],spectrometer_hosts=['localhost'], # spectrometer_tcp_ports=[25144],spectrometer_udp_ports=[16210], # spectrometer_channels=[[8192,8192]], # formatnames=c.Format,raw_formats=[form[f] for f in c.Format], basename=c.Directory + ('' if c.Directory[-1] is '/' else '/'), # sweep=c.Sweep, full_file=c.NSpec, freq=c.Frequency, integration_time=int(c.IntegrationTime * 1000.), blank_time=c.BlankTime, antenna_offset=c.Antenna) self.HKvalues.measurements = self.measurements # init/deinit measurement def measureInitToggle(self): if self.running: self.init = True else: self.init = not self.init if not self.running and self.init: self.measureThread.do('init') else: self.measureThread.do('close') self.sender().setChecked(self.init) self.Controlvalues.setDisabled(self.init) # if self.oemrunning: self.oeminit = True else: self.oeminit = not self.oeminit if not self.oemrunning and self.oeminit: self.oemThread.do('init') else: self.oemThread.do('close') # start/stop measurement def measureStartStop(self): if self.init: self.running = not self.running else: self.running = False if self.running: self.measureThread.do('run') else: self.measureThread.do(None) self.sender().setChecked(self.running) if self.oeminit: self.oemrunning = not self.oemrunning else: self.oemrunning = False if self.oemrunning: self.oemThread.do('run') else: self.oemThread.do(None) # timer callback function def updateTimer(self): self.timer.stop() self.time = localtime() #self.HKvalues.updateHK() if (self.measurements is not None) and ('multimeter' in self.measurements.__dict__): sensors = self.measurements.multimeter.getSensors() self.HKvalues.updateHK(sensors) elif self.measurements is not None: sensors = self.measurements.multimeter.getSensors() self.HKvalues.updateHK(sensors) if self.init: self.sBar.setInfo("Initialized", "preview") else: self.sBar.setInfo("Stopped", "stop1") if self.measurements is not None: spec, tabs = self.measurements.spec, self.centralwidget.tabs if tabs.spec != spec: tabs.removeTabs() tabs.setTabs(spec) if self.running: self.sBar.setInfo("Running", "preview") try: order = self.measurements.get_order() order = [ order[k] + str(order[0:k].count(w)) for k, w in enumerate(order) ] if len(self.measurements._housekeeping) > 0: chopper_pos = order[len(self.measurements._housekeeping) - 1] # Tc,Th=self.measurements.multimeter.getSensors()[1:3] Tc = self.measurements._housekeeping[-1][0] Th = self.measurements._housekeeping[-1][1] if Tc != 0: self._Tc = Tc if Th != 0: self._Th = Th Tc = self._Tc Th = self._Th # print(Tc,Th) # Tc,Th=21.,295. Tc = 62.3 Th = 121.5 self.centralwidget.tabs.refreshTabs( Tc, Th, order, chopper_pos) except: pass else: self.sBar.setInfo("Stopped", "stop1") self.sBar.refreshInfo() self.timer.start()
class controlWidget(QWidget): def __init__(self, parent): super(controlWidget, self).__init__() self.widgetTimer = QTimer() self.widgetTimer.start(100) self.widgetTimer.timeout.connect(self.createNewDspWidgets) self.value =0 self.flag = True self.mainApp = parent self.inactivityTimeout = True self.setWindowTitle('Live Telemetry Visualizer') self.qbtn = QPushButton('Quit', self) self.qbtn.clicked.connect(self.mainApp.quit) self.qbtn.resize(self.qbtn.sizeHint()) self.qbtn.hide() qbtn1 = QPushButton('Check Performance status') qbtn1.clicked.connect(self.ButtonPressed) qbtn1.resize(qbtn1.sizeHint()) self.performance_status = QLabel("If Performance Curve at Monitor Mic is On turn it Off") self.performance_status.hide() icheck = QCheckBox('Inactivity Timeout') icheck.stateChanged.connect(self.toggleInactivity) icheck.setChecked(self.inactivityTimeout) layout = QVBoxLayout() self.setLayout(layout) layout.addWidget(self.qbtn) layout.addWidget(self.performance_status) layout.addWidget(qbtn1) layout.addWidget(icheck) layout.addWidget(QWidget()) self.resize(180, 100) self.show() def toggleInactivity(self, state): self.inactivityTimeout = (state != 0) def ButtonPressed(self): self.performance_status.setStyleSheet("background-color: red") self.performance_status.show() self.qbtn.show() def placeWidget(self, desktop, widget, placedwidget): screenNum = desktop.screenNumber(self) screen = desktop.screenGeometry(screenNum) size = widget.geometry() left = screen.width()-size.width() if left < 0: left = 0 top = screen.height()-size.height() if top < 0: top = 0; #left = random.randint(0, left) + screen.left() #top = random.randint(0, left) + screen.top() if placedwidget=='anc' or 'trn': left = 2 top = 2 widget.move(left, top) if placedwidget=='snk': left = 920 top = 900 widget.move(left, top) return def createNewDspWidgets(self): for displayWidget in displayWidgets: instances = dspmsg.getInstances(displayWidget['name']) for instance in instances['instances']: found = False for widget in activeWidgets: if widget.getInstanceId() == instance: found = True break if found == False: widget = displayWidget['widget']( displayWidget['name'], instance, activeWidgets, displayWidget['dataFunc'], inactivityTimeout = self.inactivityTimeout ) placedwidget=displayWidget['name'] #if self.flag: # self.value = instance # self.flag = False self.placeWidget(self.mainApp.desktop(), widget, placedwidget) widget.show()