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)
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()
