source: trunk/Puzzlebox/Synapse/Interface.py @ 413

Last change on this file since 413 was 403, checked in by sc, 8 years ago

Interface:

  • bugfix for processing custom headers
  • Property svn:executable set to *
File size: 28.1 KB
Line 
1# -*- coding: utf-8 -*-
2
3# Copyright Puzzlebox Productions, LLC (2010-2012)
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__changelog__ = """\
9Last Update: 2012.06.29
10"""
11
12__todo__ = """
13- exporting data columns twice (attention through mid gamma"
14- undesirable data in control panel's debug window:
15        Timestamp: 2012-06-29 07:53:59.336689 PDT
16        poorSignalLevel: 200
17- update configuration.ini file with settings entered into interface
18"""
19
20### IMPORTS ###
21import os, sys, time
22
23import Puzzlebox.Synapse.Configuration as configuration
24
25if configuration.ENABLE_PYSIDE:
26        try:
27                import PySide as PyQt4
28                from PySide import QtCore, QtGui, QtNetwork
29        except Exception, e:
30                print "ERROR: Exception importing PySide:",
31                print e
32                configuration.ENABLE_PYSIDE = False
33        else:
34                print "INFO: [Synapse:Interface] Using PySide module"
35
36if not configuration.ENABLE_PYSIDE:
37        print "INFO: [Synapse:Interface] Using PyQt4 module"
38        from PyQt4 import QtCore, QtGui, QtNetwork
39
40
41try:
42        from Interface_Plot import *
43        MATPLOTLIB_AVAILABLE = True
44except Exception, e:
45        print "ERROR: Exception importing Interface_Plot:",
46        print e
47        MATPLOTLIB_AVAILABLE = False
48
49
50if (sys.platform == 'win32'):
51        #import _winreg as winreg
52        #import itertools
53        #import re
54        #import serial
55        DEFAULT_IMAGE_PATH = 'images'
56elif (sys.platform == 'darwin'):
57        DEFAULT_IMAGE_PATH = 'images'
58else:
59        import bluetooth
60        DEFAULT_IMAGE_PATH = '/usr/share/puzzlebox_synapse/images'
61
62
63try:
64        import cPickle as pickle
65except:
66        import pickle
67
68
69from Interface_Design import Ui_Form as Design
70
71import Puzzlebox.Synapse.Device as synapse_device
72import Puzzlebox.Synapse.Session as synapse_session
73import Puzzlebox.Synapse.Client as synapse_client
74import Puzzlebox.Synapse.ThinkGear.Server as thinkgear_server
75import Puzzlebox.Synapse.Emotiv.Server as emotiv_server
76
77
78#####################################################################
79# Globals
80#####################################################################
81
82DEBUG = configuration.DEBUG
83
84SYNAPSE_SERVER_HOST = configuration.SYNAPSE_SERVER_HOST
85SYNAPSE_SERVER_PORT = configuration.SYNAPSE_SERVER_PORT
86
87EMULATE_THINKGEAR_FOR_EMOTIV = configuration.EMULATE_THINKGEAR_FOR_EMOTIV
88
89#THINKGEAR_EEG_POWER_BAND_ORDER = configuration.THINKGEAR_EEG_POWER_BAND_ORDER
90
91THINKGEAR_EMULATION_MAX_ESENSE_VALUE = \
92        configuration.THINKGEAR_EMULATION_MAX_ESENSE_VALUE
93THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE = \
94        configuration.THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE
95
96PATH_TO_HCITOOL = '/usr/bin/hcitool'
97
98#UPDATE_INTERFACE_VIA_TIMER = True # Alternative is to establish a
99                                  ## ThinkGear Connect client which
100                                  ## updates the interface on demand
101                                  ## as packets are received
102
103UPDATE_INTERFACE_VIA_TIMER = False
104
105#INTERFACE_UPDATE_FREQUENCY = (1 / 512) * 1000 # ms (512 Hz)
106INTERFACE_UPDATE_FREQUENCY = 1000 # ms
107
108INTERFACE_RAW_EEG_UPDATE_FREQUENCY = 512
109
110PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD = 0.75
111
112
113#####################################################################
114# Classes
115#####################################################################
116
117class puzzlebox_synapse_interface(synapse_device.puzzlebox_synapse_device, \
118                                  synapse_session.puzzlebox_synapse_session, \
119                                  Design):
120       
121        def __init__(self, log, \
122                     DEBUG=DEBUG, \
123                     parent=None, \
124                     embedded_mode=False):
125               
126                self.log = log
127                self.DEBUG = DEBUG
128                self.parent=parent
129                self.embedded_mode=embedded_mode
130               
131                if self.parent == None:
132                        QtGui.QWidget.__init__(self, parent)
133                        self.setupUi(self)
134               
135                        self.configureSettings()
136                        self.connectWidgets()
137               
138                self.name = "Synapse:Interface"
139               
140                self.synapseServer = None
141                self.synapseClient = None
142                #self.thinkgearConnectClient = None
143                #self.emotivClient = None
144               
145                self.session_start_timestamp = time.time()
146                self.plugin_session = self # for compatability with Puzzlebox Jigsaw
147               
148                self.maxEEGPower = THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE
149               
150                self.debug_console_buffer = ''
151               
152                self.packets = {}
153                self.packets['rawEeg'] = []
154                self.packets['signals'] = []
155               
156                self.customDataHeaders = []
157               
158                self.session_start_timestamp = time.time()
159                self.packet_count = 0
160                self.bad_packets = 0
161               
162                if UPDATE_INTERFACE_VIA_TIMER:
163                        self.updateInterfaceTimer = QtCore.QTimer()
164                        QtCore.QObject.connect(self.updateInterfaceTimer, \
165                                                    QtCore.SIGNAL("timeout()"), \
166                                                    self.updateInterface)
167               
168               
169               
170                self.activePlugins = [self]
171       
172       
173        ##################################################################
174       
175        def configureSettings(self):
176               
177                # Synapse Interface
178                image_path = "puzzlebox.ico"
179                if not os.path.exists(image_path):
180                        image_path = os.path.join(DEFAULT_IMAGE_PATH, image_path)
181               
182                if os.path.exists(image_path):
183                        icon = QtGui.QIcon()
184                        icon.addPixmap(QtGui.QPixmap(image_path), \
185                                            QtGui.QIcon.Normal, \
186                                            QtGui.QIcon.Off)
187                        self.setWindowIcon(icon)
188               
189                image_path = "puzzlebox_logo.png"
190                if not os.path.exists(image_path):
191                        image_path = os.path.join(DEFAULT_IMAGE_PATH, image_path)
192                if os.path.exists(image_path):
193                        self.labelPuzzleboxIcon.setPixmap(QtGui.QPixmap(image_path))
194               
195               
196                if (sys.platform == 'win32'):
197                        self.homepath = os.path.join( \
198                           os.environ['HOMEDRIVE'], \
199                           os.environ['HOMEPATH'], \
200                           'Desktop')
201                elif (sys.platform == 'darwin'):
202                        desktop = os.path.join(os.environ['HOME'], 'Documents')
203                        if os.path.exists(desktop):
204                                self.homepath = desktop
205                        else:
206                                self.homepath = os.environ['HOME']
207                else:
208                        desktop = os.path.join(os.environ['HOME'], 'Desktop')
209                        if os.path.exists(desktop):
210                                self.homepath = desktop
211                        else:
212                                self.homepath = os.environ['HOME']
213               
214               
215                if not os.path.exists(self.homepath):
216                        if self.DEBUG:
217                                print "DEBUG: User default path not found"
218                        self.homepath = os.getcwd()
219               
220               
221                if configuration.INTERFACE_TAB_POSITION == 'South':
222                        self.tabWidget.setTabPosition(QtGui.QTabWidget.South)
223                else:
224                        self.tabWidget.setTabPosition(QtGui.QTabWidget.North)
225               
226               
227                # EEG Devices
228                self.updateDevices()
229               
230               
231                # Connect Server
232                self.textLabelBluetoothStatus.setText("Status: Disconnected")
233               
234                # Display Host for ThinkGear Connect Socket Server
235                self.lineEditSynapseHost.setText(SYNAPSE_SERVER_HOST)
236               
237                # Display Port for ThinkGear Connect Socket Server
238                self.lineEditSynapsePort.setText('%i' % SYNAPSE_SERVER_PORT)
239               
240               
241                # ThinkgGear Progress Bars
242                self.progressBarEEGDelta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
243                self.progressBarEEGTheta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
244                self.progressBarEEGLowAlpha.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
245                self.progressBarEEGHighAlpha.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
246                self.progressBarEEGLowBeta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
247                self.progressBarEEGHighBeta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
248                self.progressBarEEGLowGamma.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
249                self.progressBarEEGMidGamma.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
250               
251                self.progressBarAttention.setMaximum(THINKGEAR_EMULATION_MAX_ESENSE_VALUE)
252                self.progressBarMeditation.setMaximum(THINKGEAR_EMULATION_MAX_ESENSE_VALUE)
253               
254                self.progressBarSignalContactQuality.setMaximum(200)
255               
256               
257                if MATPLOTLIB_AVAILABLE:
258                        self.rawEEGMatplot = rawEEGMatplotlibCanvas( \
259                                                self.tabEEGSignals, \
260                                                width=8, \
261                                                height=4, \
262                                                dpi=100, \
263                                                title='Raw EEG Waves')
264                        self.chartEEGMatplot = chartEEGMatplotlibCanvas( \
265                                                self.tabCharts, \
266                                                width=8, \
267                                                height=4, \
268                                                dpi=100, \
269                                                title='EEG Brain Signals')
270               
271                else:
272                        self.tabWidget.removeTab(self.tabWidget.indexOf(self.tabEEGSignals))
273                        self.tabWidget.removeTab(self.tabWidget.indexOf(self.tabCharts))
274       
275       
276        ##################################################################
277       
278        def connectWidgets(self):
279               
280                self.connect(self.comboBoxEEGHeadsetModel, \
281                             QtCore.SIGNAL("currentIndexChanged(int)"), \
282                             self.updateDevices)
283               
284                self.connect(self.pushButtonBluetoothSearch, \
285                             QtCore.SIGNAL("clicked()"), \
286                             self.updateDevices)
287               
288                self.connect(self.pushButtonSynapseServer, \
289                             QtCore.SIGNAL("clicked()"), \
290                             self.startSynapseServer)
291               
292                self.connect(self.pushButtonSave, \
293                             QtCore.SIGNAL("clicked()"), \
294                             self.saveData)
295               
296                self.connect(self.pushButtonExport, \
297                             QtCore.SIGNAL("clicked()"), \
298                             self.exportData)
299               
300                self.connect(self.pushButtonReset, \
301                             QtCore.SIGNAL("clicked()"), \
302                             self.resetData)
303       
304       
305        ##################################################################
306       
307        def updateInterface(self):
308               
309                if not self.synapseServer.emulate_headset_data:
310                        #self.processPacketThinkGear( \
311                        self.processPacketEEG( \
312                                self.synapseServer.protocol.data_packet)
313       
314       
315        ##################################################################
316       
317        def updateDevices(self):
318               
319                if (self.parent != None):
320                        source = self.parent
321                else:
322                        source = self
323               
324                model = source.comboBoxEEGHeadsetModel.currentText()
325               
326                devices = self.searchForDevices()
327               
328                source.comboBoxDeviceSelect.clear()
329               
330                if (model == 'NeuroSky MindWave' or \
331                    model == 'NeuroSky MindSet' or \
332                    model == 'NeuroSky MindWave Mobile'):
333                       
334                        devices.insert(0, 'ThinkGear Emulator')
335               
336                elif (model == 'Emotiv EPOC'):
337                       
338                        devices = []
339                        devices.append('Emotiv Control Panel')
340                        devices.append('EmoComposer')
341               
342               
343                for device in devices:
344                        source.comboBoxDeviceSelect.addItem(device)
345       
346       
347        ##################################################################
348       
349        def startSynapseServer(self):
350               
351                eeg_headset_model = str(self.comboBoxEEGHeadsetModel.currentText())
352                #device_address = str(self.comboBoxDeviceSelect.currentText())
353                server_interface = str(self.lineEditSynapseHost.text())
354                server_port = int(self.lineEditSynapsePort.text())
355               
356               
357                if ((eeg_headset_model == 'NeuroSky MindWave Mobile') or \
358                    (eeg_headset_model == 'NeuroSky MindWave') or \
359                    (eeg_headset_model == 'NeuroSky MindSet')):
360                       
361                        self.startThinkGearConnectService()
362               
363                elif (eeg_headset_model == 'Emotiv EPOC'):
364                       
365                        self.startEmotivService()
366               
367               
368                if UPDATE_INTERFACE_VIA_TIMER:
369                        self.updateInterfaceTimer.start(INTERFACE_UPDATE_FREQUENCY)
370               
371                else:
372                        self.synapseClient = \
373                                synapse_client.puzzlebox_synapse_client( \
374                                        self.log, \
375                                        server_host=server_interface, \
376                                        server_port=server_port, \
377                                        DEBUG=0, \
378                                        parent=self)
379                       
380                        self.synapseClient.start()
381               
382               
383                device_selection = self.comboBoxDeviceSelect.currentText()
384                self.textLabelBluetoothStatus.setText("Status: Connected")
385                self.pushButtonBluetoothSearch.setEnabled(False)
386                self.comboBoxDeviceSelect.setEnabled(False)
387                self.comboBoxEEGHeadsetModel.setEnabled(False)
388               
389                self.lineEditSynapseHost.setEnabled(False)
390                self.lineEditSynapsePort.setEnabled(False)
391               
392                self.pushButtonSynapseServer.setText('Stop')
393               
394                self.progressBarEEGDelta.setValue(0)
395                self.progressBarEEGTheta.setValue(0)
396                self.progressBarEEGLowAlpha.setValue(0)
397                self.progressBarEEGHighAlpha.setValue(0)
398                self.progressBarEEGLowBeta.setValue(0)
399                self.progressBarEEGHighBeta.setValue(0)
400                self.progressBarEEGLowGamma.setValue(0)
401                self.progressBarEEGMidGamma.setValue(0)
402               
403                self.progressBarAttention.setValue(0)
404                self.progressBarMeditation.setValue(0)
405               
406               
407                self.disconnect(self.pushButtonSynapseServer, \
408                                     QtCore.SIGNAL("clicked()"), \
409                                     self.startSynapseServer)
410               
411                self.connect(self.pushButtonSynapseServer, \
412                                  QtCore.SIGNAL("clicked()"), \
413                                  self.stopSynapseServer)
414       
415       
416        ##################################################################
417       
418        def stopSynapseServer(self):
419               
420                eeg_headset_model = str(self.comboBoxEEGHeadsetModel.currentText())
421                #device_address = str(self.comboBoxDeviceSelect.currentText())
422               
423                if ((eeg_headset_model == 'NeuroSky MindWave Mobile') or \
424                    (eeg_headset_model == 'NeuroSky MindWave') or \
425                    (eeg_headset_model == 'NeuroSky MindSet')):
426                       
427                        self.stopThinkGearConnectService()
428               
429                elif (eeg_headset_model == 'Emotiv EPOC'):
430                       
431                        self.stopEmotivService()
432               
433               
434                if UPDATE_INTERFACE_VIA_TIMER:
435                        self.updateInterfaceTimer.stop()
436                else:
437                        try:
438                                self.synapseClient.exitThread()
439                                #self.synapseClient.disconnectFromHost()
440                        except Exception, e:
441                                if self.DEBUG:
442                                        print "Call failed to self.synapseClient.exitThread():",
443                                        #print "Call failed to self.synapseClient.disconnectFromHost():",
444                                        print e
445                       
446                        try:
447                                self.synapseServer.exitThread()
448                        except Exception, e:
449                                if self.DEBUG:
450                                        print "Call failed to self.synapseServer.exitThread():",
451                                        print e
452               
453               
454                self.disconnect(self.pushButtonSynapseServer, \
455                                QtCore.SIGNAL("clicked()"), \
456                                self.stopSynapseServer)
457               
458                self.connect(self.pushButtonSynapseServer, \
459                                  QtCore.SIGNAL("clicked()"), \
460                                  self.startSynapseServer)
461               
462                self.lineEditSynapseHost.setEnabled(True)
463                self.lineEditSynapsePort.setEnabled(True)
464               
465                self.pushButtonSynapseServer.setText('Start')
466               
467                self.pushButtonBluetoothSearch.setEnabled(True)
468               
469                self.pushButtonSynapseServer.setChecked(False)
470               
471                self.textLabelBluetoothStatus.setText("Status: Disconnected")
472               
473                self.pushButtonBluetoothSearch.setEnabled(True)
474               
475                self.comboBoxDeviceSelect.setEnabled(True)
476                self.comboBoxEEGHeadsetModel.setEnabled(True)
477               
478               
479                self.progressBarEEGDelta.setValue(0)
480                self.progressBarEEGTheta.setValue(0)
481                self.progressBarEEGLowAlpha.setValue(0)
482                self.progressBarEEGHighAlpha.setValue(0)
483                self.progressBarEEGLowBeta.setValue(0)
484                self.progressBarEEGHighBeta.setValue(0)
485                self.progressBarEEGLowGamma.setValue(0)
486                self.progressBarEEGMidGamma.setValue(0)
487               
488                self.progressBarAttention.setValue(0)
489                self.progressBarMeditation.setValue(0)
490               
491                self.progressBarSignalContactQuality.setValue(0)
492               
493                self.maxEEGPower = THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE
494               
495                # In case the user connects to a MindSet, then disconnects
496                # and re-connects to a MindSet Emulator,
497                # we need to reset the max power values
498                self.progressBarEEGDelta.setMaximum(self.maxEEGPower)
499                self.progressBarEEGTheta.setMaximum(self.maxEEGPower)
500                self.progressBarEEGLowAlpha.setMaximum(self.maxEEGPower)
501                self.progressBarEEGHighAlpha.setMaximum(self.maxEEGPower)
502                self.progressBarEEGLowBeta.setMaximum(self.maxEEGPower)
503                self.progressBarEEGHighBeta.setMaximum(self.maxEEGPower)
504                self.progressBarEEGLowGamma.setMaximum(self.maxEEGPower)
505                self.progressBarEEGMidGamma.setMaximum(self.maxEEGPower)
506       
507       
508        ##################################################################
509       
510        def startThinkGearConnectService(self):
511               
512                eeg_headset_model = str(self.comboBoxEEGHeadsetModel.currentText())
513                device_address = str(self.comboBoxDeviceSelect.currentText())
514                server_interface = str(self.lineEditSynapseHost.text())
515                server_port = int(self.lineEditSynapsePort.text())
516                emulate_headset_data = (device_address == 'ThinkGear Emulator')
517               
518               
519                self.synapseServer = \
520                        thinkgear_server.puzzlebox_synapse_server_thinkgear( \
521                                self.log, \
522                                server_interface=server_interface, \
523                                server_port=server_port, \
524                                device_model=eeg_headset_model, \
525                                device_address=device_address, \
526                                emulate_headset_data=emulate_headset_data, \
527                                DEBUG=DEBUG, \
528                                parent=self)
529               
530                for header in self.synapseServer.customDataHeaders:
531                        if header not in self.customDataHeaders:
532                                self.customDataHeaders.append(header)
533               
534                self.synapseServer.start()
535       
536       
537        ##################################################################
538       
539        def stopThinkGearConnectService(self):
540               
541                for header in self.synapseServer.customDataHeaders:
542                        if header in self.customDataHeaders:
543                               
544                                index = self.customDataHeaders.index(header)
545                               
546                                del(self.customDataHeaders[index])
547       
548       
549        ##################################################################
550       
551        def startEmotivService(self):
552               
553                device_address = str(self.comboBoxDeviceSelect.currentText())
554               
555                if device_address == 'Emotiv Control Panel':
556                        device_address = configuration.EMOTIV_SERVER_PORT_CONTROL_PANEL
557                else:
558                        device_address = configuration.EMOTIV_SERVER_PORT_EMOCOMPOSER
559               
560               
561                server_interface = str(self.lineEditSynapseHost.text())
562                server_port = int(self.lineEditSynapsePort.text())
563                eeg_headset_model = str(self.comboBoxEEGHeadsetModel.currentText())
564                emulate_headset_data = (device_address == 'ThinkGear Emulator')
565               
566               
567                self.synapseServer = \
568                        emotiv_server.puzzlebox_synapse_server_emotiv( \
569                                self.log, \
570                                server_interface=server_interface, \
571                                server_port=server_port, \
572                                device_model=eeg_headset_model, \
573                                device_address=device_address, \
574                                emulate_headset_data=emulate_headset_data, \
575                                DEBUG=DEBUG, \
576                                parent=self)
577               
578                for header in self.synapseServer.customDataHeaders:
579                        if header not in self.customDataHeaders:
580                                self.customDataHeaders.append(header)
581               
582                self.synapseServer.start()
583               
584               
585                self.progressBarEEGDelta.setEnabled(False)
586                self.progressBarEEGTheta.setEnabled(False)
587                self.progressBarEEGLowAlpha.setEnabled(False)
588                self.progressBarEEGHighAlpha.setEnabled(False)
589                self.progressBarEEGLowBeta.setEnabled(False)
590                self.progressBarEEGHighBeta.setEnabled(False)
591                self.progressBarEEGLowGamma.setEnabled(False)
592                self.progressBarEEGMidGamma.setEnabled(False)
593               
594                #self.progressBarAttention.setEnabled(False)
595                #self.progressBarMeditation.setEnabled(False)
596       
597       
598        ##################################################################
599       
600        def stopEmotivService(self):
601               
602                #self.emotivClient.stop()
603               
604                self.progressBarEEGDelta.setEnabled(True)
605                self.progressBarEEGTheta.setEnabled(True)
606                self.progressBarEEGLowAlpha.setEnabled(True)
607                self.progressBarEEGHighAlpha.setEnabled(True)
608                self.progressBarEEGLowBeta.setEnabled(True)
609                self.progressBarEEGHighBeta.setEnabled(True)
610                self.progressBarEEGLowGamma.setEnabled(True)
611                self.progressBarEEGMidGamma.setEnabled(True)
612               
613                #self.progressBarAttention.setEnabled(True)
614                #self.progressBarMeditation.setEnabled(True)
615       
616                for header in self.synapseServer.customDataHeaders:
617                        if header in self.customDataHeaders:
618                                del(self.customDataHeaders[header])
619       
620       
621        ##################################################################
622       
623        def processPacketEEG(self, packet):
624               
625                self.processPacketThinkGear(packet)
626                self.processPacketEmotiv(packet)
627               
628               
629                #if ((self.synapseServer.protocol != None) and
630                if (self.tabWidget.currentIndex() == \
631                    self.tabWidget.indexOf(self.tabControlPanel)):
632                       
633                        self.updateProfileSessionStatus()
634       
635       
636        ##################################################################
637       
638        def processPacketThinkGear(self, packet):
639               
640                #if self.DEBUG > 2:
641                        #print packet
642               
643               
644                if ('rawEeg' in packet.keys()):
645                        self.packets['rawEeg'].append(packet['rawEeg'])
646                        value = packet['rawEeg']
647                        if MATPLOTLIB_AVAILABLE and \
648                                (self.tabWidget.currentIndex() == \
649                                 self.tabWidget.indexOf(self.tabEEGSignals)):
650                                self.rawEEGMatplot.update_figure(value)
651                        return
652                else:
653                        # NOTE: This is also logging Emotiv packets to 'signals'
654                        self.packets['signals'].append(packet)
655               
656               
657                if ('poorSignalLevel' in packet.keys()):
658                        value = 200 - packet['poorSignalLevel']
659                        self.progressBarSignalContactQuality.setValue(value)
660                        self.textEditDebugConsole.append("")
661                        try:
662                                (date, localtime) = self.parseTimeStamp(packet['timestamp'])
663                                self.textEditDebugConsole.append("Timestamp: %s %s" % (date, localtime))
664                        except:
665                                pass
666                        self.textEditDebugConsole.append("poorSignalLevel: %i" % \
667                                                         packet['poorSignalLevel'])
668               
669               
670                if ('eSense' in packet.keys()):
671                       
672                        if ('attention' in packet['eSense'].keys()):
673                                value = packet['eSense']['attention']
674                                self.progressBarAttention.setValue(value)
675                                self.textEditDebugConsole.append("eSense attention: %i" % value)
676                       
677                        if ('meditation' in packet['eSense'].keys()):
678                                value = packet['eSense']['meditation']
679                                self.progressBarMeditation.setValue(value)
680                                self.textEditDebugConsole.append("eSense meditation: %i" % value)
681                       
682                       
683                        if MATPLOTLIB_AVAILABLE:
684                                self.chartEEGMatplot.update_values('eSense', packet['eSense'])
685                                if (self.tabWidget.currentIndex() == \
686                                    self.tabWidget.indexOf(self.tabCharts)):
687                                        self.chartEEGMatplot.update_figure('eSense', packet['eSense'])
688               
689               
690                if ('eegPower' in packet.keys()):
691                       
692                        # If we are not emulating packets we'll set the maximum EEG Power value
693                        # threshold to the default (or maximum value found within this packet)
694                        if not self.synapseServer.emulate_headset_data:
695                                self.maxEEGPower = THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE
696                       
697                        for value in packet['eegPower'].keys():
698                                if packet['eegPower'][value] > self.maxEEGPower:
699                                        self.maxEEGPower = packet['eegPower'][value]
700                       
701                       
702                        if ('delta' in packet['eegPower'].keys()):
703                                value = packet['eegPower']['delta']
704                                self.progressBarEEGDelta.setMaximum(self.maxEEGPower)
705                                self.progressBarEEGDelta.setValue(value)
706                                self.textEditDebugConsole.append("delta: %i" % value)
707                       
708                        if ('theta' in packet['eegPower'].keys()):
709                                value = packet['eegPower']['theta']
710                                self.progressBarEEGTheta.setMaximum(self.maxEEGPower)
711                                self.progressBarEEGTheta.setValue(value)
712                                self.textEditDebugConsole.append("theta: %i" % value)
713                       
714                        if ('lowAlpha' in packet['eegPower'].keys()):
715                                value = packet['eegPower']['lowAlpha']
716                                self.progressBarEEGLowAlpha.setMaximum(self.maxEEGPower)
717                                self.progressBarEEGLowAlpha.setValue(value)
718                                self.textEditDebugConsole.append("lowAlpha: %i" % value)
719                       
720                        if ('highAlpha' in packet['eegPower'].keys()):
721                                value = packet['eegPower']['highAlpha']
722                                self.progressBarEEGHighAlpha.setMaximum(self.maxEEGPower)
723                                self.progressBarEEGHighAlpha.setValue(value)
724                                self.textEditDebugConsole.append("highAlpha: %i" % value)
725                       
726                        if ('lowBeta' in packet['eegPower'].keys()):
727                                value = packet['eegPower']['lowBeta']
728                                self.progressBarEEGLowBeta.setMaximum(self.maxEEGPower)
729                                self.progressBarEEGLowBeta.setValue(value)
730                                self.textEditDebugConsole.append("lowBeta: %i" % value)
731                       
732                        if ('highBeta' in packet['eegPower'].keys()):
733                                value = packet['eegPower']['highBeta']
734                                self.progressBarEEGHighBeta.setMaximum(self.maxEEGPower)
735                                self.progressBarEEGHighBeta.setValue(value)
736                                self.textEditDebugConsole.append("highBeta: %i" % value)
737                       
738                        if ('lowGamma' in packet['eegPower'].keys()):
739                                value = packet['eegPower']['lowGamma']
740                                self.progressBarEEGLowGamma.setMaximum(self.maxEEGPower)
741                                self.progressBarEEGLowGamma.setValue(value)
742                                self.textEditDebugConsole.append("lowGamma: %i" % value)
743                       
744                        if ('highGamma' in packet['eegPower'].keys()):
745                                value = packet['eegPower']['highGamma']
746                                self.progressBarEEGMidGamma.setMaximum(self.maxEEGPower)
747                                self.progressBarEEGMidGamma.setValue(value)
748                                self.textEditDebugConsole.append("highGamma: %i" % value)
749                       
750                       
751                        if MATPLOTLIB_AVAILABLE:
752                                self.chartEEGMatplot.update_values('eegPower', packet['eegPower'])
753                                if (self.tabWidget.currentIndex() == \
754                                    self.tabWidget.indexOf(self.tabCharts)):
755                                        self.chartEEGMatplot.update_figure('eegPower', packet['eegPower'])
756       
757       
758        ##################################################################
759       
760        def processPacketEmotiv(self, packet):
761               
762                if self.DEBUG > 2:
763                        print "INFO [Synapse:Interface] Emotiv packet received:"
764                        print packet
765               
766               
767                if ('emotivStatus' in packet.keys()):
768                       
769                        if ('timeFromStart' in packet['emotivStatus']):
770                                if not configuration.EMULATE_THINKGEAR_FOR_EMOTIV:
771                                        self.textEditDebugConsole.append("")
772                                        try:
773                                                (date, localtime) = self.parseTimeStamp(packet['timestamp'])
774                                                self.textEditDebugConsole.append("Timestamp: %s %s" % (date, localtime))
775                                        except:
776                                                pass
777                                self.textEditDebugConsole.append("timeFromStart: %f" % \
778                                                                  packet['emotivStatus']['timeFromStart'])
779                       
780                        if ('headsetOn' in packet['emotivStatus']):
781                                self.textEditDebugConsole.append("headsetOn: %s" % \
782                                                                  bool(packet['emotivStatus']['headsetOn']))
783                       
784                        if ('contactNumberOfQualityChannels' in packet['emotivStatus']):
785                                self.textEditDebugConsole.append("contactNumberOfQualityChannels: %i" % \
786                                                                  packet['emotivStatus']['contactNumberOfQualityChannels'])
787                       
788                        if ('wireless' in packet['emotivStatus']):
789                                self.textEditDebugConsole.append("wireless: %i" % \
790                                                                  packet['emotivStatus']['wireless'])
791               
792               
793                if ('affectiv' in packet.keys()):
794                       
795                        if ('excitement' in packet['affectiv']):
796                                self.textEditDebugConsole.append("excitement: %.2f" % \
797                                                                  packet['affectiv']['excitement'])
798                       
799                        if ('longTermExcitement' in packet['affectiv']):
800                                self.textEditDebugConsole.append("longTermExcitement: %.2f" % \
801                                                                  packet['affectiv']['longTermExcitement'])
802                       
803                        if ('meditation' in packet['affectiv']):
804                                self.textEditDebugConsole.append("meditation: %.2f" % \
805                                                                  packet['affectiv']['meditation'])
806                       
807                        if ('frustration' in packet['affectiv']):
808                                self.textEditDebugConsole.append("frustration: %.2f" % \
809                                                                  packet['affectiv']['frustration'])
810                       
811                        if ('engagementBoredom' in packet['affectiv']):
812                                self.textEditDebugConsole.append("engagementBoredom: %.2f" % \
813                                                                  packet['affectiv']['engagementBoredom'])
814               
815               
816                if ('cognitiv' in packet.keys()):
817                       
818                        if ('currentAction' in packet['cognitiv']):
819                                self.textEditDebugConsole.append("currentAction: %i" % \
820                                                                  packet['cognitiv']['currentAction'])
821                       
822                        if ('currentActionPower' in packet['cognitiv']):
823                                self.textEditDebugConsole.append("currentActionPower: %.2f" % \
824                                                                  packet['cognitiv']['currentActionPower'])
825       
826       
827       
828        ##################################################################
829       
830        def setPacketCount(self, value):
831               
832                self.packet_count = value
833       
834       
835        ##################################################################
836       
837        def setBadPackets(self, value):
838               
839                self.bad_packets = value
840       
841       
842        ##################################################################
843       
844        def incrementPacketCount(self):
845               
846                self.packet_count += 1
847       
848       
849        ##################################################################
850       
851        def incrementBadPackets(self):
852               
853                self.bad_packets += 1
854       
855       
856        ##################################################################
857       
858        def getPacketCount(self):
859               
860                return (self.packet_count)
861       
862       
863        ##################################################################
864       
865        def getBadPackets(self):
866               
867                return (self.bad_packets)
868       
869       
870        ##################################################################
871       
872        def getSessionTime(self):
873               
874                return (self.session_start_timestamp)
875       
876       
877        ##################################################################
878       
879        def resetSessionStartTime(self):
880       
881                #self.synapseServer.protocol.resetSessionStartTime()
882                #self.resetSessionStartTime()
883                self.session_start_timestamp = time.time()
884       
885       
886        ##################################################################
887       
888        def processPacketForExport(self, packet={}, output={}):
889               
890                if self.synapseServer != None:
891                        output = self.synapseServer.processPacketForExport(packet, output)
892               
893                return(output)
894       
895       
896        ##################################################################
897       
898        def stop(self):
899               
900                if UPDATE_INTERFACE_VIA_TIMER:
901                        self.updateInterfaceTimer.stop()
902                else:
903                        if self.synapseClient != None:
904                                self.synapseClient.exitThread()
905                        #if self.thinkgearConnectClient != None:
906                                #self.thinkgearConnectClient.exitThread()
907                        #if self.emotivClient != None:
908                                #self.emotivClient.exitThread()
909               
910                if self.synapseServer != None:
911                        self.synapseServer.exitThread()
912       
913       
914        ##################################################################
915       
916        def closeEvent(self, event):
917               
918                quit_message = "Are you sure you want to exit the program?"
919               
920                reply = QtGui.QMessageBox.question( \
921                           self, \
922                          'Message', \
923                           quit_message, \
924                           QtGui.QMessageBox.Yes, \
925                           QtGui.QMessageBox.No)
926               
927                if reply == QtGui.QMessageBox.Yes:
928                       
929                        self.stop()
930                       
931                        event.accept()
932               
933                else:
934                        event.ignore()
935
Note: See TracBrowser for help on using the repository browser.