source: trunk/synapse/Puzzlebox/Synapse/Interface.py @ 192

Last change on this file since 192 was 192, checked in by sc, 12 years ago

trunk/synapse/interface/puzzlebox_synapse_interface_design.ui

  • Control Panel tab cleaned up

trunk/synapse/Puzzlebox/Synapse/Interface.py:

  • Control Panel session and packet statistics calculated
  • Control Panel buttons connected to functions
  • convert_seconds_to_datetime function added

trunk/synapse/Puzzlebox/Synapse/Protocol.py:

  • session time, packet count, and bad packet counters added


  • Property svn:executable set to *
File size: 21.0 KB
Line 
1# -*- coding: utf-8 -*-
2
3# Copyright Puzzlebox Productions, LLC (2010)
4#
5# This code is released under the GNU Pulic License (GPL) version 2
6# For more information please refer to http://www.gnu.org/copyleft/gpl.html
7
8# Old Class Names:
9#       puzzlebox_synapse_interface = QtUI
10
11__changelog__ = """\
12Last Update: 2010.09.21
13
14"""
15
16__todo__ = """
17- update configuration.ini file with settings entered into interface
18
19"""
20
21### IMPORTS ###
22import os, sys, time
23import simplejson as json
24
25try:
26        from Interface_Plot import *
27        MATPLOTLIB_AVAILABLE = True
28except:
29        MATPLOTLIB_AVAILABLE = False
30
31if (sys.platform != 'win32'):
32        import bluetooth
33        DEFAULT_IMAGE_PATH = '/usr/share/puzzlebox_synapse/images'
34else:
35        import _winreg as winreg
36        import itertools
37        import re
38        import serial
39        DEFAULT_IMAGE_PATH = 'images'
40
41try:
42        import PySide as PyQt4
43        from PySide import QtCore, QtGui
44except:
45        print "Using PyQt4 module"
46        from PyQt4 import QtCore, QtGui
47else:
48        print "Using PySide module"
49
50# from puzzlebox_synapse_interface_design import Ui_Form
51from Interface_Design import Ui_Form as Design
52
53import Configuration as configuration
54import Server as synapse_server
55import Client as thinkgear_client
56#import puzzlebox_logger
57
58### GLOBALS ###
59
60DEBUG = 1
61
62THINKGEAR_SERVER_HOST = configuration.THINKGEAR_SERVER_HOST
63THINKGEAR_SERVER_PORT = configuration.THINKGEAR_SERVER_PORT
64
65THINKGEAR_EEG_POWER_BAND_ORDER = configuration.THINKGEAR_EEG_POWER_BAND_ORDER
66
67THINKGEAR_EMULATION_MAX_ESENSE_VALUE = \
68        configuration.THINKGEAR_EMULATION_MAX_ESENSE_VALUE
69THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE = \
70        configuration.THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE
71
72PATH_TO_HCITOOL = '/usr/bin/hcitool'
73
74#UPDATE_INTERFACE_VIA_TIMER = True # Alternative is to establish a
75                                  ## ThinkGear Connect client which
76                                  ## updates the interface on demand
77                                  ## as packets are received
78
79UPDATE_INTERFACE_VIA_TIMER = False
80
81#INTERFACE_UPDATE_FREQUENCY = (1 / 512) * 1000 # ms (512 Hz)
82INTERFACE_UPDATE_FREQUENCY = 1000 # ms
83
84INTERFACE_RAW_EEG_UPDATE_FREQUENCY = 512
85
86### CLASSES ###
87
88class QtUI(QtGui.QWidget, Design):
89       
90        def __init__(self, log, server=None, DEBUG=DEBUG, parent = None):
91               
92                self.log = log
93                self.DEBUG = DEBUG
94               
95                QtGui.QWidget.__init__(self, parent)
96                self.setupUi(self)
97               
98                self.configureSettings()
99                self.connectWidgets()
100               
101                self.name = "Synapse Interface"
102               
103                self.thinkGearConnectServer = None
104                self.thinkgearConnectClient = None
105               
106                self.maxEEGPower = THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE
107               
108                self.debug_console_buffer = ''
109               
110                if UPDATE_INTERFACE_VIA_TIMER:
111                        self.updateInterfaceTimer = QtCore.QTimer()
112                        QtCore.QObject.connect(self.updateInterfaceTimer, \
113                                                    QtCore.SIGNAL("timeout()"), \
114                                                    self.updateInterface)
115       
116       
117        ##################################################################
118       
119        def configureSettings(self):
120               
121                # Synapse Interface
122                image_path = "puzzlebox.ico"
123                if not os.path.exists(image_path):
124                        image_path = os.path.join(DEFAULT_IMAGE_PATH, image_path)
125               
126                if os.path.exists(image_path):
127                        icon = QtGui.QIcon()
128                        icon.addPixmap(QtGui.QPixmap(image_path), \
129                                            QtGui.QIcon.Normal, \
130                                            QtGui.QIcon.Off)
131                        self.setWindowIcon(icon)
132               
133                image_path = "puzzlebox_logo.png"
134                if not os.path.exists(image_path):
135                        image_path = os.path.join(DEFAULT_IMAGE_PATH, image_path)
136                if os.path.exists(image_path):
137                        self.labelPuzzleboxIcon.setPixmap(QtGui.QPixmap(image_path))
138               
139               
140                # ThinkGear Device
141                self.searchForThinkGearDevices()
142               
143               
144                # ThinkGear Connect Server
145                self.textLabelBluetoothStatus.setText("Status: Disconnected")
146               
147                # Display Host for ThinkGear Connect Socket Server
148                self.lineEditThinkGearHost.setText(THINKGEAR_SERVER_HOST)
149               
150                # Display Port for ThinkGear Connect Socket Server
151                self.lineEditThinkGearPort.setText('%i' % THINKGEAR_SERVER_PORT)
152               
153               
154                # ThinkgGear Progress Bars
155                self.progressBarEEGDelta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
156                self.progressBarEEGTheta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
157                self.progressBarEEGLowAlpha.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
158                self.progressBarEEGHighAlpha.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
159                self.progressBarEEGLowBeta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
160                self.progressBarEEGHighBeta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
161                self.progressBarEEGLowGamma.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
162                self.progressBarEEGMidGamma.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
163               
164                self.progressBarAttention.setMaximum(THINKGEAR_EMULATION_MAX_ESENSE_VALUE)
165                self.progressBarMeditation.setMaximum(THINKGEAR_EMULATION_MAX_ESENSE_VALUE)
166               
167                self.progressBarSignalContactQuality.setMaximum(200)
168               
169               
170                if MATPLOTLIB_AVAILABLE:
171                        self.rawEEGMatplot = rawEEGMatplotlibCanvas( \
172                                                self.tabEEGSignals, \
173                                                width=8, \
174                                                height=4, \
175                                                dpi=100, \
176                                                title='Raw EEG Waves')
177                        self.chartEEGMatplot = chartEEGMatplotlibCanvas( \
178                                                self.tabCharts, \
179                                                width=8, \
180                                                height=4, \
181                                                dpi=100, \
182                                                title='EEG Brain Signals')
183               
184                else:
185                        self.tabWidget.removeTab(self.tabWidget.indexOf(self.tabEEGSignals))
186                        self.tabWidget.removeTab(self.tabWidget.indexOf(self.tabCharts))
187       
188       
189        ##################################################################
190       
191        def connectWidgets(self):
192               
193                self.connect(self.pushButtonBluetoothSearch, \
194                                  QtCore.SIGNAL("clicked()"), \
195                                  self.searchForThinkGearDevices)
196               
197                self.connect(self.pushButtonBluetoothConnect, \
198                                  QtCore.SIGNAL("clicked()"), \
199                                  self.connectToThinkGearDevice)
200               
201                self.connect(self.pushButtonThinkGearConnect, \
202                                  QtCore.SIGNAL("clicked()"), \
203                                  self.startThinkGearConnectServer)
204               
205                self.connect(self.pushButtonSave, \
206                                  QtCore.SIGNAL("clicked()"), \
207                                  self.saveData)
208               
209                self.connect(self.pushButtonExport, \
210                                  QtCore.SIGNAL("clicked()"), \
211                                  self.exportData)
212               
213                self.connect(self.pushButtonReset, \
214                                  QtCore.SIGNAL("clicked()"), \
215                                  self.resetData)
216       
217       
218        ##################################################################
219       
220        def connectToThinkGearDevice(self):
221               
222                device_selection = self.comboBoxDeviceSelect.currentText()
223               
224                self.disconnect(self.pushButtonBluetoothConnect, \
225                                     QtCore.SIGNAL("clicked()"), \
226                                     self.connectToThinkGearDevice)
227               
228                self.connect(self.pushButtonBluetoothConnect, \
229                                  QtCore.SIGNAL("clicked()"), \
230                                  self.disconnectFromThinkGearDevice)
231               
232                self.textLabelBluetoothStatus.setText("Status: Connected")
233               
234                self.pushButtonBluetoothSearch.setEnabled(False)
235               
236                self.pushButtonBluetoothConnect.setText('Disconnect')
237                self.pushButtonBluetoothConnect.setChecked(True)
238               
239                self.comboBoxDeviceSelect.setEnabled(False)
240       
241       
242        ##################################################################
243       
244        def disconnectFromThinkGearDevice(self):
245               
246                self.disconnect(self.pushButtonBluetoothConnect, \
247                                     QtCore.SIGNAL("clicked()"), \
248                                     self.disconnectFromThinkGearDevice)
249               
250                self.connect(self.pushButtonBluetoothConnect, \
251                                  QtCore.SIGNAL("clicked()"), \
252                                  self.connectToThinkGearDevice)
253               
254                self.textLabelBluetoothStatus.setText("Status: Disconnected")
255               
256                self.pushButtonBluetoothSearch.setEnabled(True)
257               
258                self.pushButtonBluetoothConnect.setText('Connect')
259                self.pushButtonBluetoothConnect.setChecked(False)
260               
261                self.comboBoxDeviceSelect.setEnabled(True)
262               
263               
264                self.progressBarEEGDelta.setValue(0)
265                self.progressBarEEGTheta.setValue(0)
266                self.progressBarEEGLowAlpha.setValue(0)
267                self.progressBarEEGHighAlpha.setValue(0)
268                self.progressBarEEGLowBeta.setValue(0)
269                self.progressBarEEGHighBeta.setValue(0)
270                self.progressBarEEGLowGamma.setValue(0)
271                self.progressBarEEGMidGamma.setValue(0)
272               
273                self.progressBarAttention.setValue(0)
274                self.progressBarMeditation.setValue(0)
275               
276                self.progressBarSignalContactQuality.setValue(0)
277               
278                self.maxEEGPower = THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE
279               
280                # In case the user connects to a MindSet, then disconnects
281                # and re-connects to a MindSet Emulator,
282                # we need to reset the max power values
283                self.progressBarEEGDelta.setMaximum(self.maxEEGPower)
284                self.progressBarEEGTheta.setMaximum(self.maxEEGPower)
285                self.progressBarEEGLowAlpha.setMaximum(self.maxEEGPower)
286                self.progressBarEEGHighAlpha.setMaximum(self.maxEEGPower)
287                self.progressBarEEGLowBeta.setMaximum(self.maxEEGPower)
288                self.progressBarEEGHighBeta.setMaximum(self.maxEEGPower)
289                self.progressBarEEGLowGamma.setMaximum(self.maxEEGPower)
290                self.progressBarEEGMidGamma.setMaximum(self.maxEEGPower)
291       
292       
293        ##################################################################
294       
295        def startThinkGearConnectServer(self):
296               
297                # Ensure EEG device is connected first
298               
299                if not self.pushButtonBluetoothConnect.isChecked():
300                        self.connectToThinkGearDevice()
301               
302               
303                self.pushButtonBluetoothSearch.setEnabled(False)
304                self.pushButtonBluetoothConnect.setEnabled(False)
305               
306                server_interface = str(self.lineEditThinkGearHost.text())
307                server_port = int(self.lineEditThinkGearPort.text())
308                device_address = str(self.comboBoxDeviceSelect.currentText())
309                emulate_headset_data = (device_address == 'MindSet Emulator')
310               
311               
312                self.thinkGearConnectServer = \
313                        synapse_server.ThinkgearServer( \
314                                self.log, \
315                                server_interface=server_interface, \
316                                server_port=server_port, \
317                                device_address=device_address, \
318                                emulate_headset_data=emulate_headset_data, \
319                                DEBUG=DEBUG, \
320                                parent=self)
321               
322                self.thinkGearConnectServer.start()
323               
324               
325                if UPDATE_INTERFACE_VIA_TIMER:
326                        self.updateInterfaceTimer.start(INTERFACE_UPDATE_FREQUENCY)
327               
328                else:
329                        self.thinkgearConnectClient = \
330                                thinkgear_client.QtClient( \
331                                        self.log, \
332                                        server_host=server_interface, \
333                                        server_port=server_port, \
334                                        DEBUG=0, \
335                                        parent=self)
336                       
337                        self.thinkgearConnectClient.start()
338               
339               
340                self.disconnect(self.pushButtonThinkGearConnect, \
341                                     QtCore.SIGNAL("clicked()"), \
342                                     self.startThinkGearConnectServer)
343               
344                self.connect(self.pushButtonThinkGearConnect, \
345                                  QtCore.SIGNAL("clicked()"), \
346                                  self.stopThinkGearConnectServer)
347               
348                self.lineEditThinkGearHost.setEnabled(False)
349                self.lineEditThinkGearPort.setEnabled(False)
350               
351                self.pushButtonThinkGearConnect.setText('Stop')
352       
353       
354        ##################################################################
355       
356        def stopThinkGearConnectServer(self):
357               
358                if UPDATE_INTERFACE_VIA_TIMER:
359                        self.updateInterfaceTimer.stop()
360                else:
361                        try:
362                                self.thinkgearConnectClient.disconnectFromHost()
363                        except Exception, e:
364                                if self.DEBUG:
365                                        print "Call failed to self.thinkgearConnectClient.disconnectFromHost():",
366                                        print e
367
368                try:
369                        self.thinkGearConnectServer.exitThread()
370                except Exception, e:
371                        if self.DEBUG:
372                                print "Call failed to self.thinkGearConnectServer.exitThread():",
373                                print e
374               
375                self.disconnect(self.pushButtonThinkGearConnect, \
376                                     QtCore.SIGNAL("clicked()"), \
377                                     self.stopThinkGearConnectServer)
378               
379                self.connect(self.pushButtonThinkGearConnect, \
380                                  QtCore.SIGNAL("clicked()"), \
381                                  self.startThinkGearConnectServer)
382               
383                self.lineEditThinkGearHost.setEnabled(True)
384                self.lineEditThinkGearPort.setEnabled(True)
385               
386                self.pushButtonThinkGearConnect.setText('Start')
387               
388                #self.pushButtonBluetoothSearch.setEnabled(True)
389                self.pushButtonBluetoothConnect.setEnabled(True)
390
391                self.pushButtonThinkGearConnect.setChecked(False)
392       
393       
394        ##################################################################
395       
396        def updateInterface(self):
397               
398                if not self.thinkGearConnectServer.emulate_headset_data:
399                        self.processPacketThinkGear( \
400                                self.thinkGearConnectServer.protocol.data_packet)
401       
402       
403        ##################################################################
404       
405        def processPacketThinkGear(self, packet):
406               
407                if self.DEBUG > 2:
408                        print packet
409               
410               
411                if ('rawEeg' in packet.keys()):
412                        value = packet['rawEeg']
413                        if MATPLOTLIB_AVAILABLE and \
414                                (self.tabWidget.currentIndex() == \
415                                        self.tabWidget.indexOf(self.tabEEGSignals)):
416                                self.rawEEGMatplot.update_figure(value)
417               
418               
419                if ('poorSignalLevel' in packet.keys()):
420                        value = 200 - packet['poorSignalLevel']
421                        self.progressBarSignalContactQuality.setValue(value)
422                        self.textEditDebugConsole.append("")
423                        self.textEditDebugConsole.append("poorSignalLevel: %i" % \
424                                                              packet['poorSignalLevel'])
425               
426               
427                if ('eSense' in packet.keys()):
428                       
429                        if ('attention' in packet['eSense'].keys()):
430                                value = packet['eSense']['attention']
431                                self.progressBarAttention.setValue(value)
432                                self.textEditDebugConsole.append("eSense attention: %i" % value)
433                       
434                        if ('meditation' in packet['eSense'].keys()):
435                                value = packet['eSense']['meditation']
436                                self.progressBarMeditation.setValue(value)
437                                self.textEditDebugConsole.append("eSense meditation: %i" % value)
438                       
439                       
440                        if MATPLOTLIB_AVAILABLE:
441                                self.chartEEGMatplot.update_values('eSense', packet['eSense'])
442                                if (self.tabWidget.currentIndex() == \
443                                    self.tabWidget.indexOf(self.tabCharts)):
444                                        self.chartEEGMatplot.update_figure('eSense', packet['eSense'])
445               
446               
447                if ('eegPower' in packet.keys()):
448                       
449                        # If we are not emulating packets we'll set the maximum EEG Power value
450                        # threshold to the default (or maximum value found within this packet)
451                        if not self.thinkGearConnectServer.emulate_headset_data:
452                                self.maxEEGPower = THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE
453                       
454                        for value in packet['eegPower'].keys():
455                                if packet['eegPower'][value] > self.maxEEGPower:
456                                        self.maxEEGPower = packet['eegPower'][value]
457                       
458                       
459                        if ('delta' in packet['eegPower'].keys()):
460                                value = packet['eegPower']['delta']
461                                self.progressBarEEGDelta.setMaximum(self.maxEEGPower)
462                                self.progressBarEEGDelta.setValue(value)
463                                self.textEditDebugConsole.append("delta: %i" % value)
464                       
465                        if ('theta' in packet['eegPower'].keys()):
466                                value = packet['eegPower']['theta']
467                                self.progressBarEEGTheta.setMaximum(self.maxEEGPower)
468                                self.progressBarEEGTheta.setValue(value)
469                                self.textEditDebugConsole.append("theta: %i" % value)
470                       
471                        if ('lowAlpha' in packet['eegPower'].keys()):
472                                value = packet['eegPower']['lowAlpha']
473                                self.progressBarEEGLowAlpha.setMaximum(self.maxEEGPower)
474                                self.progressBarEEGLowAlpha.setValue(value)
475                                self.textEditDebugConsole.append("lowAlpha: %i" % value)
476                       
477                        if ('highAlpha' in packet['eegPower'].keys()):
478                                value = packet['eegPower']['highAlpha']
479                                self.progressBarEEGHighAlpha.setMaximum(self.maxEEGPower)
480                                self.progressBarEEGHighAlpha.setValue(value)
481                                self.textEditDebugConsole.append("highAlpha: %i" % value)
482                       
483                        if ('lowBeta' in packet['eegPower'].keys()):
484                                value = packet['eegPower']['lowBeta']
485                                self.progressBarEEGLowBeta.setMaximum(self.maxEEGPower)
486                                self.progressBarEEGLowBeta.setValue(value)
487                                self.textEditDebugConsole.append("lowBeta: %i" % value)
488                       
489                        if ('highBeta' in packet['eegPower'].keys()):
490                                value = packet['eegPower']['highBeta']
491                                self.progressBarEEGHighBeta.setMaximum(self.maxEEGPower)
492                                self.progressBarEEGHighBeta.setValue(value)
493                                self.textEditDebugConsole.append("highBeta: %i" % value)
494                       
495                        if ('lowGamma' in packet['eegPower'].keys()):
496                                value = packet['eegPower']['lowGamma']
497                                self.progressBarEEGLowGamma.setMaximum(self.maxEEGPower)
498                                self.progressBarEEGLowGamma.setValue(value)
499                                self.textEditDebugConsole.append("lowGamma: %i" % value)
500                       
501                        if ('highGamma' in packet['eegPower'].keys()):
502                                value = packet['eegPower']['highGamma']
503                                self.progressBarEEGMidGamma.setMaximum(self.maxEEGPower)
504                                self.progressBarEEGMidGamma.setValue(value)
505                                self.textEditDebugConsole.append("highGamma: %i" % value)
506                       
507                       
508                        if MATPLOTLIB_AVAILABLE:
509                                self.chartEEGMatplot.update_values('eegPower', packet['eegPower'])
510                                if (self.tabWidget.currentIndex() == \
511                                    self.tabWidget.indexOf(self.tabCharts)):
512                                        self.chartEEGMatplot.update_figure('eegPower', packet['eegPower'])
513               
514               
515                if ((self.thinkGearConnectServer.protocol != None) and
516                    (self.tabWidget.currentIndex() == \
517                     self.tabWidget.indexOf(self.tabControlPanel))):
518                       
519                        session_time = time.time() - \
520                                self.thinkGearConnectServer.protocol.session_start_timestamp
521                       
522                        session_time = int(session_time)
523                       
524                        session_time = self.convert_seconds_to_datetime(session_time)
525                       
526                        self.textLabelSessionTime.setText(session_time)
527                       
528                        self.textLabelPacketsReceived.setText( "%i" % \
529                                self.thinkGearConnectServer.protocol.packet_count)
530                        self.textLabelPacketsDropped.setText( "%i" % \
531                                self.thinkGearConnectServer.protocol.bad_packets)
532       
533       
534        ##################################################################
535       
536        def enumerateSerialPorts(self):
537               
538                """ Uses the Win32 registry to return an
539                iterator of serial (COM) ports
540                existing on this computer.
541               
542                from http://eli.thegreenplace.net/2009/07/31/listing-all-serial-ports-on-windows-with-python/
543                """
544         
545                path = 'HARDWARE\\DEVICEMAP\\SERIALCOMM'
546                try:
547                        key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path)
548                except WindowsError:
549                        #raise IterationError
550                        return
551               
552                for i in itertools.count():
553                        try:
554                                val = winreg.EnumValue(key, i)
555                                yield str(val[1])
556                        except EnvironmentError:
557                                break
558       
559       
560        ##################################################################
561       
562        def fullPortName(self, portname):
563               
564                """ Given a port-name (of the form COM7,
565                COM12, CNCA0, etc.) returns a full
566                name suitable for opening with the
567                Serial class.
568                """
569               
570                m = re.match('^COM(\d+)$', portname)
571                if m and int(m.group(1)) < 10:
572                        return portname
573               
574                return '\\\\.\\' + portname
575       
576       
577        ##################################################################
578       
579        def searchForThinkGearDevices(self):
580               
581                #self.pushButtonBluetoothSearch.setText('Searching')
582               
583                mindset_devices = []
584               
585                if (sys.platform == 'win32'):
586                       
587                        for portname in self.enumerateSerialPorts():
588                               
589                                if portname not in mindset_devices:
590                                        #portname = self.fullPortName(portname)
591                                        mindset_devices.append(portname)
592               
593               
594                else:
595                       
596                        # Bluetooth module doesn't compile properly under Windows
597                       
598                        bluetooth_devices = []
599                       
600                        #bluetooth_devices = bluetooth.discover_devices( \
601                                                    #duration=5, \
602                                                    #flush_cache=True, \
603                                                    #lookup_names=True)
604                       
605                        command = '%s con' % PATH_TO_HCITOOL
606                       
607                        output = os.popen(command, 'r')
608                       
609                        for line in output.readlines():
610                                try:
611                                        address = line.split(' ')[2]
612                                except:
613                                        pass
614                                else:
615                                        bluetooth_devices.append(address)
616                       
617                        for address in bluetooth_devices:
618                                device_name = bluetooth.lookup_name(address)
619                                if ((device_name == 'MindSet') and \
620                                    (address not in mindset_devices)):
621                                        mindset_devices.append(address)
622                       
623                       
624                        if self.DEBUG:
625                                print "Bluetooth MindSet devices found:",
626                                print mindset_devices
627                       
628                       
629                        self.comboBoxDeviceSelect.clear()
630                       
631                        self.comboBoxDeviceSelect.addItem('MindSet Emulator')
632               
633               
634                for mindset_device in mindset_devices:
635                        self.comboBoxDeviceSelect.addItem(mindset_device)
636               
637               
638                #self.pushButtonBluetoothSearch.setText('Search')
639       
640       
641        ##################################################################
642       
643        def saveData(self):
644               
645                pass
646       
647       
648        ##################################################################
649       
650        def exportData(self):
651               
652                pass
653       
654       
655        ##################################################################
656       
657        def resetData(self):
658               
659                pass
660       
661       
662        #####################################################################
663       
664        def convert_seconds_to_datetime(self, duration):
665               
666                duration_hours = duration / (60 * 60)
667                duration_minutes = (duration - (duration_hours * (60 * 60))) / 60
668                duration_seconds = (duration - (duration_hours * (60 * 60)) - (duration_minutes * 60))
669               
670                duration_hours = '%i' % duration_hours
671                if (len(duration_hours) == 1):
672                        duration_hours = "0%s" % duration_hours
673               
674                duration_minutes = '%i' % duration_minutes
675                if (len(duration_minutes) == 1):
676                        duration_minutes = "0%s" % duration_minutes
677               
678                duration_seconds = '%i' % duration_seconds
679                if (len(duration_seconds) == 1):
680                        duration_seconds = "0%s" % duration_seconds
681               
682                datetime = '%s:%s:%s' % (duration_hours, duration_minutes, duration_seconds)
683               
684                return(datetime)
685       
686       
687        ##################################################################
688       
689        def closeEvent(self, event):
690               
691                quit_message = "Are you sure you want to exit the program?"
692               
693                reply = QtGui.QMessageBox.question( \
694                           self, \
695                          'Message', \
696                           quit_message, \
697                           QtGui.QMessageBox.Yes, \
698                           QtGui.QMessageBox.No)
699               
700                if reply == QtGui.QMessageBox.Yes:
701                       
702                        if UPDATE_INTERFACE_VIA_TIMER:
703                                self.updateInterfaceTimer.stop()
704                        else:
705                                if self.thinkgearConnectClient != None:
706                                        self.thinkgearConnectClient.disconnectFromHost()
707                       
708                        if self.thinkGearConnectServer != None:
709                                self.thinkGearConnectServer.exitThread()
710                       
711                        event.accept()
712               
713                else:
714                        event.ignore()
Note: See TracBrowser for help on using the repository browser.