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

Last change on this file since 193 was 193, checked in by sc, 11 years ago

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

  • saveData completed
  • exportData completed
  • resetData completed
  • collectData added
  • updateProfileSessionStatus added
  • calculateSessionTime added

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

  • whitespace cleanup

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

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