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

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

synapse/Puzzlebox/Synapse/Interface.py:

  • Date and Timestamp added to console output
  • Property svn:executable set to *
File size: 23.6 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 parseTimeStamp(self, timestamp, local_version=False):
415               
416                print timestamp
417               
418                try:
419                        decimal = '%f' % timestamp
420                        decimal = decimal.split('.')[1]
421                except:
422                        decimal = '0'
423               
424                localtime = time.localtime(timestamp)
425               
426                if local_version:
427                        date = time.strftime('%x', localtime)
428                        localtime = time.strftime('%X', localtime)
429               
430                else:
431                        date = time.strftime('%Y-%m-%d', localtime)
432                        localtime = time.strftime('%H:%M:%S', localtime)
433                        localtime = '%s.%s %s' % (localtime, decimal, \
434                                       time.strftime('%Z', time.localtime(timestamp)))
435               
436               
437                return(date, localtime)
438       
439       
440        ##################################################################
441       
442        def processPacketThinkGear(self, packet):
443               
444                if self.DEBUG > 2:
445                        print packet
446               
447               
448                if ('rawEeg' in packet.keys()):
449                        self.packets['rawEeg'].append(packet['rawEeg'])
450                        value = packet['rawEeg']
451                        if MATPLOTLIB_AVAILABLE and \
452                                (self.tabWidget.currentIndex() == \
453                                 self.tabWidget.indexOf(self.tabEEGSignals)):
454                                self.rawEEGMatplot.update_figure(value)
455                else:
456                        self.packets['signals'].append(packet)
457               
458               
459                if ('poorSignalLevel' in packet.keys()):
460                        value = 200 - packet['poorSignalLevel']
461                        self.progressBarSignalContactQuality.setValue(value)
462                        self.textEditDebugConsole.append("")
463                        (date, localtime) = self.parseTimeStamp(packet['timestamp'])
464                        self.textEditDebugConsole.append("Timestamp: %s %s" % (date, localtime))
465                        self.textEditDebugConsole.append("poorSignalLevel: %i" % \
466                                                         packet['poorSignalLevel'])
467               
468               
469                if ('eSense' in packet.keys()):
470                       
471                        if ('attention' in packet['eSense'].keys()):
472                                value = packet['eSense']['attention']
473                                self.progressBarAttention.setValue(value)
474                                self.textEditDebugConsole.append("eSense attention: %i" % value)
475                       
476                        if ('meditation' in packet['eSense'].keys()):
477                                value = packet['eSense']['meditation']
478                                self.progressBarMeditation.setValue(value)
479                                self.textEditDebugConsole.append("eSense meditation: %i" % value)
480                       
481                       
482                        if MATPLOTLIB_AVAILABLE:
483                                self.chartEEGMatplot.update_values('eSense', packet['eSense'])
484                                if (self.tabWidget.currentIndex() == \
485                                    self.tabWidget.indexOf(self.tabCharts)):
486                                        self.chartEEGMatplot.update_figure('eSense', packet['eSense'])
487               
488               
489                if ('eegPower' in packet.keys()):
490                       
491                        # If we are not emulating packets we'll set the maximum EEG Power value
492                        # threshold to the default (or maximum value found within this packet)
493                        if not self.thinkGearConnectServer.emulate_headset_data:
494                                self.maxEEGPower = THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE
495                       
496                        for value in packet['eegPower'].keys():
497                                if packet['eegPower'][value] > self.maxEEGPower:
498                                        self.maxEEGPower = packet['eegPower'][value]
499                       
500                       
501                        if ('delta' in packet['eegPower'].keys()):
502                                value = packet['eegPower']['delta']
503                                self.progressBarEEGDelta.setMaximum(self.maxEEGPower)
504                                self.progressBarEEGDelta.setValue(value)
505                                self.textEditDebugConsole.append("delta: %i" % value)
506                       
507                        if ('theta' in packet['eegPower'].keys()):
508                                value = packet['eegPower']['theta']
509                                self.progressBarEEGTheta.setMaximum(self.maxEEGPower)
510                                self.progressBarEEGTheta.setValue(value)
511                                self.textEditDebugConsole.append("theta: %i" % value)
512                       
513                        if ('lowAlpha' in packet['eegPower'].keys()):
514                                value = packet['eegPower']['lowAlpha']
515                                self.progressBarEEGLowAlpha.setMaximum(self.maxEEGPower)
516                                self.progressBarEEGLowAlpha.setValue(value)
517                                self.textEditDebugConsole.append("lowAlpha: %i" % value)
518                       
519                        if ('highAlpha' in packet['eegPower'].keys()):
520                                value = packet['eegPower']['highAlpha']
521                                self.progressBarEEGHighAlpha.setMaximum(self.maxEEGPower)
522                                self.progressBarEEGHighAlpha.setValue(value)
523                                self.textEditDebugConsole.append("highAlpha: %i" % value)
524                       
525                        if ('lowBeta' in packet['eegPower'].keys()):
526                                value = packet['eegPower']['lowBeta']
527                                self.progressBarEEGLowBeta.setMaximum(self.maxEEGPower)
528                                self.progressBarEEGLowBeta.setValue(value)
529                                self.textEditDebugConsole.append("lowBeta: %i" % value)
530                       
531                        if ('highBeta' in packet['eegPower'].keys()):
532                                value = packet['eegPower']['highBeta']
533                                self.progressBarEEGHighBeta.setMaximum(self.maxEEGPower)
534                                self.progressBarEEGHighBeta.setValue(value)
535                                self.textEditDebugConsole.append("highBeta: %i" % value)
536                       
537                        if ('lowGamma' in packet['eegPower'].keys()):
538                                value = packet['eegPower']['lowGamma']
539                                self.progressBarEEGLowGamma.setMaximum(self.maxEEGPower)
540                                self.progressBarEEGLowGamma.setValue(value)
541                                self.textEditDebugConsole.append("lowGamma: %i" % value)
542                       
543                        if ('highGamma' in packet['eegPower'].keys()):
544                                value = packet['eegPower']['highGamma']
545                                self.progressBarEEGMidGamma.setMaximum(self.maxEEGPower)
546                                self.progressBarEEGMidGamma.setValue(value)
547                                self.textEditDebugConsole.append("highGamma: %i" % value)
548                       
549                       
550                        if MATPLOTLIB_AVAILABLE:
551                                self.chartEEGMatplot.update_values('eegPower', packet['eegPower'])
552                                if (self.tabWidget.currentIndex() == \
553                                    self.tabWidget.indexOf(self.tabCharts)):
554                                        self.chartEEGMatplot.update_figure('eegPower', packet['eegPower'])
555               
556               
557                if ((self.thinkGearConnectServer.protocol != None) and
558                    (self.tabWidget.currentIndex() == \
559                     self.tabWidget.indexOf(self.tabControlPanel))):
560                       
561                        self.updateProfileSessionStatus()
562       
563       
564        ##################################################################
565       
566        def updateProfileSessionStatus(self):
567               
568                session_time = self.calculateSessionTime()
569               
570                self.textLabelSessionTime.setText(session_time)
571               
572                self.textLabelPacketsReceived.setText( "%i" % \
573                        self.thinkGearConnectServer.protocol.packet_count)
574                self.textLabelPacketsDropped.setText( "%i" % \
575                        self.thinkGearConnectServer.protocol.bad_packets)
576       
577       
578        ##################################################################
579       
580        def calculateSessionTime(self):
581               
582                session_time = time.time() - \
583                        self.thinkGearConnectServer.protocol.session_start_timestamp
584               
585                session_time = int(session_time)
586               
587                session_time = self.convert_seconds_to_datetime(session_time)
588               
589                return(session_time)
590       
591       
592        ##################################################################
593       
594        def enumerateSerialPorts(self):
595               
596                """ Uses the Win32 registry to return an
597                iterator of serial (COM) ports
598                existing on this computer.
599               
600                from http://eli.thegreenplace.net/2009/07/31/listing-all-serial-ports-on-windows-with-python/
601                """
602         
603                path = 'HARDWARE\\DEVICEMAP\\SERIALCOMM'
604                try:
605                        key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path)
606                except WindowsError:
607                        #raise IterationError
608                        return
609               
610                for i in itertools.count():
611                        try:
612                                val = winreg.EnumValue(key, i)
613                                yield str(val[1])
614                        except EnvironmentError:
615                                break
616       
617       
618        ##################################################################
619       
620        def fullPortName(self, portname):
621               
622                """ Given a port-name (of the form COM7,
623                COM12, CNCA0, etc.) returns a full
624                name suitable for opening with the
625                Serial class.
626                """
627               
628                m = re.match('^COM(\d+)$', portname)
629                if m and int(m.group(1)) < 10:
630                        return portname
631               
632                return '\\\\.\\' + portname
633       
634       
635        ##################################################################
636       
637        def searchForThinkGearDevices(self):
638               
639                #self.pushButtonBluetoothSearch.setText('Searching')
640               
641                mindset_devices = []
642               
643                if (sys.platform == 'win32'):
644                       
645                        for portname in self.enumerateSerialPorts():
646                               
647                                if portname not in mindset_devices:
648                                        #portname = self.fullPortName(portname)
649                                        mindset_devices.append(portname)
650               
651               
652                else:
653                       
654                        # Bluetooth module doesn't compile properly under Windows
655                       
656                        bluetooth_devices = []
657                       
658                        #bluetooth_devices = bluetooth.discover_devices( \
659                                                    #duration=5, \
660                                                    #flush_cache=True, \
661                                                    #lookup_names=True)
662                       
663                        command = '%s con' % PATH_TO_HCITOOL
664                       
665                        output = os.popen(command, 'r')
666                       
667                        for line in output.readlines():
668                                try:
669                                        address = line.split(' ')[2]
670                                except:
671                                        pass
672                                else:
673                                        bluetooth_devices.append(address)
674                       
675                        for address in bluetooth_devices:
676                                device_name = bluetooth.lookup_name(address)
677                                if ((device_name == 'MindSet') and \
678                                    (address not in mindset_devices)):
679                                        mindset_devices.append(address)
680                       
681                       
682                        if self.DEBUG:
683                                print "Bluetooth MindSet devices found:",
684                                print mindset_devices
685                       
686                       
687                        self.comboBoxDeviceSelect.clear()
688                       
689                        self.comboBoxDeviceSelect.addItem('MindSet Emulator')
690               
691               
692                for mindset_device in mindset_devices:
693                        self.comboBoxDeviceSelect.addItem(mindset_device)
694               
695               
696                #self.pushButtonBluetoothSearch.setText('Search')
697       
698       
699        ##################################################################
700       
701        def collectData(self):
702               
703                data = {}
704               
705                data['rawEeg'] = self.packets['rawEeg']
706                data['signals'] = self.packets['signals']
707               
708                data['sessionTime'] = self.calculateSessionTime()
709               
710                data['profileName'] = str(self.lineEditSessionProfile.text())
711               
712                return(data)
713       
714       
715        ##################################################################
716       
717        def saveData(self):
718               
719                data = self.collectData()
720               
721                #output_file = 'data.synapse'
722               
723                output_file = QtGui.QFileDialog.getSaveFileName(self, \
724                                 "Save Synapse Data File", \
725                                 "", \
726                                 "Synapse Data File (*.synapse)")
727               
728               
729                file = open(output_file, 'w')
730                pickle.dump(data, file)
731                file.close()
732       
733       
734        ##################################################################
735       
736        def exportData(self):
737               
738                textOutput = self.textEditDebugConsole.toPlainText()
739               
740                #output_file = 'text.synapse'
741               
742                output_file = QtGui.QFileDialog.getSaveFileName(self, \
743                                 "Export Synapse Data to File", \
744                                 "", \
745                                 "Text File (*.txt)")
746               
747                file = open(output_file, 'w')
748                file.write(textOutput)
749                file.close()
750       
751       
752        ##################################################################
753       
754        def resetData(self):
755               
756                self.packets['rawEeg'] = []
757                self.packets['signals'] = []
758               
759                self.thinkGearConnectServer.protocol.session_start_timestamp = \
760                        time.time()
761               
762                self.thinkGearConnectServer.protocol.packet_count = 0
763                self.thinkGearConnectServer.protocol.bad_packets = 0
764               
765                self.updateProfileSessionStatus()
766               
767                self.textEditDebugConsole.setText("")
768       
769       
770        #####################################################################
771       
772        def convert_seconds_to_datetime(self, duration):
773               
774                duration_hours = duration / (60 * 60)
775                duration_minutes = (duration - (duration_hours * (60 * 60))) / 60
776                duration_seconds = (duration - (duration_hours * (60 * 60)) - (duration_minutes * 60))
777               
778                duration_hours = '%i' % duration_hours
779                if (len(duration_hours) == 1):
780                        duration_hours = "0%s" % duration_hours
781               
782                duration_minutes = '%i' % duration_minutes
783                if (len(duration_minutes) == 1):
784                        duration_minutes = "0%s" % duration_minutes
785               
786                duration_seconds = '%i' % duration_seconds
787                if (len(duration_seconds) == 1):
788                        duration_seconds = "0%s" % duration_seconds
789               
790                datetime = '%s:%s:%s' % (duration_hours, duration_minutes, duration_seconds)
791               
792                return(datetime)
793       
794       
795        ##################################################################
796       
797        def closeEvent(self, event):
798               
799                quit_message = "Are you sure you want to exit the program?"
800               
801                reply = QtGui.QMessageBox.question( \
802                           self, \
803                          'Message', \
804                           quit_message, \
805                           QtGui.QMessageBox.Yes, \
806                           QtGui.QMessageBox.No)
807               
808                if reply == QtGui.QMessageBox.Yes:
809                       
810                        if UPDATE_INTERFACE_VIA_TIMER:
811                                self.updateInterfaceTimer.stop()
812                        else:
813                                if self.thinkgearConnectClient != None:
814                                        self.thinkgearConnectClient.disconnectFromHost()
815                       
816                        if self.thinkGearConnectServer != None:
817                                self.thinkGearConnectServer.exitThread()
818                       
819                        event.accept()
820               
821                else:
822                        event.ignore()
Note: See TracBrowser for help on using the repository browser.