Changeset 370 for trunk


Ignore:
Timestamp:
04/02/12 04:33:09 (8 years ago)
Author:
sc
Message:

Session:

  • splitting shared routines out of Interface
Location:
trunk/Puzzlebox/Synapse
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/Puzzlebox/Synapse/Interface.py

    r369 r370  
    6464from Interface_Design import Ui_Form as Design 
    6565 
     66import Puzzlebox.Synapse.Session as synapse_session 
    6667import Puzzlebox.Synapse.Client as synapse_client 
    6768import Puzzlebox.Synapse.ThinkGear.Server as thinkgear_server 
     
    110111##################################################################### 
    111112 
    112 class puzzlebox_synapse_interface(QtGui.QWidget, Design): 
     113#class puzzlebox_synapse_interface(QtGui.QWidget, Design, Puzzlebox.Synapse.Session.puzzlebox_synapse_session): 
     114class puzzlebox_synapse_interface(synapse_session.puzzlebox_synapse_session, Design): 
    113115         
    114116        def __init__(self, log, \ 
     
    130132                        self.connectWidgets() 
    131133                 
    132                 self.name = "Synapse Interface" 
     134                self.name = "Synapse:Interface" 
    133135                 
    134136                self.synapseServer = None 
     
    269271                 
    270272                self.connect(self.pushButtonBluetoothSearch, \ 
    271                                   QtCore.SIGNAL("clicked()"), \ 
    272                                   self.updateDevices) 
     273                             QtCore.SIGNAL("clicked()"), \ 
     274                             self.updateDevices) 
    273275                 
    274276                self.connect(self.pushButtonSynapseServer, \ 
    275                                   QtCore.SIGNAL("clicked()"), \ 
    276                                   self.startSynapseServer) 
     277                             QtCore.SIGNAL("clicked()"), \ 
     278                             self.startSynapseServer) 
    277279                 
    278280                self.connect(self.pushButtonSave, \ 
    279                                   QtCore.SIGNAL("clicked()"), \ 
    280                                   self.saveData) 
     281                             QtCore.SIGNAL("clicked()"), \ 
     282                             self.saveData) 
    281283                 
    282284                self.connect(self.pushButtonExport, \ 
    283                                   QtCore.SIGNAL("clicked()"), \ 
    284                                   self.exportData) 
     285                             QtCore.SIGNAL("clicked()"), \ 
     286                             self.exportData) 
    285287                 
    286288                self.connect(self.pushButtonReset, \ 
    287                                   QtCore.SIGNAL("clicked()"), \ 
    288                                   self.resetData) 
     289                             QtCore.SIGNAL("clicked()"), \ 
     290                             self.resetData) 
    289291         
    290292         
     
    297299                server_interface = str(self.lineEditSynapseHost.text()) 
    298300                server_port = int(self.lineEditSynapsePort.text()) 
    299                 #emulate_headset_data = (device_address == 'ThinkGear Emulator') 
    300                  
    301                  
    302                 if (eeg_headset_model == 'Emotiv EPOC'): 
    303                         emulate_headset_data = True 
    304                  
    305                  
    306                 #self.synapseServer = \ 
    307                         #synapse_server.puzzlebox_synapse_server( \ 
    308                                 #self.log, \ 
    309                                 #server_interface=server_interface, \ 
    310                                 #server_port=server_port, \ 
    311                                 #device_model=eeg_headset_model, \ 
    312                                 #device_address=device_address, \ 
    313                                 #emulate_headset_data=emulate_headset_data, \ 
    314                                 #DEBUG=DEBUG, \ 
    315                                 #parent=self) 
    316                  
    317                 #self.synapseServer.start() 
    318                  
    319                  
    320                 if ((eeg_headset_model == 'NeuroSky MindWave') or \ 
     301                 
     302                 
     303                if ((eeg_headset_model == 'NeuroSky MindWave Mobile') or \ 
     304                    (eeg_headset_model == 'NeuroSky MindWave') or \ 
    321305                    (eeg_headset_model == 'NeuroSky MindSet')): 
    322306                         
     
    326310                         
    327311                        self.startEmotivService() 
    328                  
    329312                 
    330313                 
     
    344327                 
    345328                 
    346                  
    347329                device_selection = self.comboBoxDeviceSelect.currentText() 
    348330                self.textLabelBluetoothStatus.setText("Status: Connected") 
     
    385367                device_address = str(self.comboBoxDeviceSelect.currentText()) 
    386368                 
    387                 if ((eeg_headset_model == 'NeuroSky MindWave') or \ 
     369                if ((eeg_headset_model == 'NeuroSky MindWave Mobile') or \ 
     370                    (eeg_headset_model == 'NeuroSky MindWave') or \ 
    388371                    (eeg_headset_model == 'NeuroSky MindSet')): 
    389372                         
     
    393376                         
    394377                        self.stopEmotivService() 
    395                  
    396378                 
    397379                 
     
    407389                                        #print "Call failed to self.synapseClient.disconnectFromHost():", 
    408390                                        print e 
    409                  
    410                  
    411                  
    412                 if UPDATE_INTERFACE_VIA_TIMER: 
    413                         self.updateInterfaceTimer.stop() 
    414                 else: 
     391                         
    415392                        try: 
    416393                                self.synapseServer.exitThread() 
     
    479456        def startThinkGearConnectService(self): 
    480457                 
     458                eeg_headset_model = str(self.comboBoxEEGHeadsetModel.currentText()) 
     459                device_address = str(self.comboBoxDeviceSelect.currentText()) 
    481460                server_interface = str(self.lineEditSynapseHost.text()) 
    482461                server_port = int(self.lineEditSynapsePort.text()) 
    483                 eeg_headset_model = str(self.comboBoxEEGHeadsetModel.currentText()) 
    484                 device_address = str(self.comboBoxDeviceSelect.currentText()) 
    485462                emulate_headset_data = (device_address == 'ThinkGear Emulator') 
    486463                 
     
    498475                 
    499476                self.synapseServer.start() 
    500                  
    501                  
    502                 #if UPDATE_INTERFACE_VIA_TIMER: 
    503                         #self.updateInterfaceTimer.start(INTERFACE_UPDATE_FREQUENCY) 
    504                  
    505                 #else: 
    506                         #self.thinkgearConnectClient = \ 
    507                                 #thinkgear_client.puzzlebox_synapse_thinkgear_client( \ 
    508                                         #self.log, \ 
    509                                         #server_host=server_interface, \ 
    510                                         #server_port=server_port, \ 
    511                                         #DEBUG=0, \ 
    512                                         #parent=self) 
    513                          
    514                         #self.thinkgearConnectClient.start() 
    515477         
    516478         
     
    518480         
    519481        def stopThinkGearConnectService(self): 
    520                  
    521                 #if UPDATE_INTERFACE_VIA_TIMER: 
    522                         #self.updateInterfaceTimer.stop() 
    523                 #else: 
    524                         #try: 
    525                                 #self.thinkgearConnectClient.exitThread() 
    526                                 ##self.thinkgearConnectClient.disconnectFromHost() 
    527                         #except Exception, e: 
    528                                 #if self.DEBUG: 
    529                                         #print "Call failed to self.thinkgearConnectClient.exitThread():", 
    530                                         ##print "Call failed to self.thinkgearConnectClient.disconnectFromHost():", 
    531                                         #print e 
    532482                 
    533483                pass 
     
    549499                        #server_port = configuration.EMOTIV_SERVER_PORT_EMOCOMPOSER 
    550500                        device_address = configuration.EMOTIV_SERVER_PORT_EMOCOMPOSER 
    551                  
    552                 #self.emotivClient = \ 
    553                    #emotiv_client.puzzlebox_synapse_client_emotiv( \ 
    554                       #log=self.log, \ 
    555                       #server_host=server_host, \ 
    556                       #server_port=server_port, \ 
    557                       #DEBUG=DEBUG, \ 
    558                       #parent=self) 
    559                  
    560                 #self.emotivClient.start() 
    561                  
    562501                 
    563502                 
     
    583522                 
    584523                 
    585                  
    586524                self.progressBarEEGDelta.setEnabled(False) 
    587525                self.progressBarEEGTheta.setEnabled(False) 
     
    593531                self.progressBarEEGMidGamma.setEnabled(False) 
    594532                 
    595                 self.progressBarAttention.setEnabled(False) 
    596                 self.progressBarMeditation.setEnabled(False) 
     533                #self.progressBarAttention.setEnabled(False) 
     534                #self.progressBarMeditation.setEnabled(False) 
    597535         
    598536         
     
    612550                self.progressBarEEGMidGamma.setEnabled(True) 
    613551                 
    614                 self.progressBarAttention.setEnabled(True) 
    615                 self.progressBarMeditation.setEnabled(True) 
     552                #self.progressBarAttention.setEnabled(True) 
     553                #self.progressBarMeditation.setEnabled(True) 
    616554         
    617555         
     
    839777        ################################################################## 
    840778         
    841         def updateProfileSessionStatus(self, source=None, target=None): 
    842                  
    843                 session_time = self.calculateSessionTime() 
    844                  
    845                 if source == None: 
    846                         if self.parent == None: 
    847                                 source = self 
    848                         else: 
    849                                 source = self.parent 
    850                  
    851                 if target == None: 
    852                         if self.parent == None: 
    853                                 target = self 
    854                         else: 
    855                                 target = self.parent 
    856                  
    857                 target.textLabelSessionTime.setText(session_time) 
    858                  
    859                 try: 
    860                         target.textLabelPacketsReceived.setText( "%i" % \ 
    861                                 source.synapseServer.protocol.packet_count) 
    862                 except: 
    863                         pass 
    864                  
    865                 try: 
    866                         target.textLabelPacketsDropped.setText( "%i" % \ 
    867                                 source.synapseServer.protocol.bad_packets) 
    868                 except: 
    869                         pass 
    870          
    871          
    872         ################################################################## 
    873          
    874         def calculateSessionTime(self): 
    875                  
    876                 if self.parent == None: 
    877                         server = self.synapseServer 
    878                 else: 
    879                         server = self.parent.synapseServer 
    880                  
    881                 session_time = time.time() - \ 
    882                         server.session_start_timestamp 
    883                         #server.protocol.session_start_timestamp 
    884                  
    885                 session_time = int(session_time) 
    886                  
    887                 session_time = self.convert_seconds_to_datetime(session_time) 
    888                  
    889                 return(session_time) 
    890          
    891          
    892         ################################################################## 
    893          
    894         def enumerateSerialPorts(self): 
    895                  
    896                 """ Uses the Win32 registry to return an 
    897                 iterator of serial (COM) ports 
    898                 existing on this computer. 
    899                  
    900                 from http://eli.thegreenplace.net/2009/07/31/listing-all-serial-ports-on-windows-with-python/ 
    901                 """ 
    902           
    903                 path = 'HARDWARE\\DEVICEMAP\\SERIALCOMM' 
    904                 try: 
    905                         key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path) 
    906                 except WindowsError: 
    907                         #raise IterationError 
    908                         return 
    909                  
    910                 for i in itertools.count(): 
    911                         try: 
    912                                 val = winreg.EnumValue(key, i) 
    913                                 yield str(val[1]) 
    914                         except EnvironmentError: 
    915                                 break 
    916          
    917          
    918         ################################################################## 
    919          
    920         def fullPortName(self, portname): 
    921                  
    922                 """ Given a port-name (of the form COM7, 
    923                 COM12, CNCA0, etc.) returns a full 
    924                 name suitable for opening with the 
    925                 Serial class. 
    926                 """ 
    927                  
    928                 m = re.match('^COM(\d+)$', portname) 
    929                 if m and int(m.group(1)) < 10: 
    930                         return portname 
    931                  
    932                 return '\\\\.\\' + portname 
    933          
    934          
    935         ################################################################## 
    936          
    937         def searchForSerialDevices(self, devices=[]): 
    938                  
    939                 if (sys.platform == 'win32'): 
    940                          
    941                         for portname in self.enumerateSerialPorts(): 
    942                                  
    943                                 if portname not in devices: 
    944                                         #portname = self.fullPortName(portname) 
    945                                         devices.append(portname) 
    946                  
    947                 else: 
    948                          
    949                          
    950                         if os.path.exists('/dev/tty.MindWaveMobile-SPPDev'): 
    951                                 devices.append('/dev/tty.MindWaveMobile-SPPDev') 
    952                          
    953                         if os.path.exists('/dev/tty.MindWave'): 
    954                                 devices.append('/dev/tty.MindWave') 
    955                         if os.path.exists('/dev/tty.MindWave1'): 
    956                                 devices.append('/dev/tty.MindWave1') 
    957                         if os.path.exists('/dev/tty.MindWave2'): 
    958                                 devices.append('/dev/tty.MindWave2') 
    959                         if os.path.exists('/dev/tty.MindWave3'): 
    960                                 devices.append('/dev/tty.MindWave3') 
    961                         if os.path.exists('/dev/tty.MindWave4'): 
    962                                 devices.append('/dev/tty.MindWave4') 
    963                         if os.path.exists('/dev/tty.MindWave5'): 
    964                                 devices.append('/dev/tty.MindWave5') 
    965                          
    966                         if os.path.exists('/dev/tty.MindSet-DevB'): 
    967                                 devices.append('/dev/tty.MindSet-DevB') 
    968                          
    969                         if os.path.exists('/dev/ttyUSB0'): 
    970                                 devices.append('/dev/ttyUSB0') 
    971                         if os.path.exists('/dev/ttyUSB1'): 
    972                                 devices.append('/dev/ttyUSB1') 
    973                         if os.path.exists('/dev/ttyUSB2'): 
    974                                 devices.append('/dev/ttyUSB2') 
    975                         if os.path.exists('/dev/ttyUSB3'): 
    976                                 devices.append('/dev/ttyUSB3') 
    977                         if os.path.exists('/dev/ttyUSB4'): 
    978                                 devices.append('/dev/ttyUSB4') 
    979                         if os.path.exists('/dev/ttyUSB5'): 
    980                                 devices.append('/dev/ttyUSB5') 
    981                         if os.path.exists('/dev/ttyUSB6'): 
    982                                 devices.append('/dev/ttyUSB6') 
    983                         if os.path.exists('/dev/ttyUSB7'): 
    984                                 devices.append('/dev/ttyUSB7') 
    985                         if os.path.exists('/dev/ttyUSB8'): 
    986                                 devices.append('/dev/ttyUSB8') 
    987                         if os.path.exists('/dev/ttyUSB9'): 
    988                                 devices.append('/dev/ttyUSB9') 
    989                          
    990                         if os.path.exists('/dev/rfcomm0'): 
    991                                 devices.append('/dev/rfcomm0') 
    992                         if os.path.exists('/dev/rfcomm1'): 
    993                                 devices.append('/dev/rfcomm1') 
    994                         if os.path.exists('/dev/rfcomm2'): 
    995                                 devices.append('/dev/rfcomm2') 
    996                         if os.path.exists('/dev/rfcomm3'): 
    997                                 devices.append('/dev/rfcomm3') 
    998                         if os.path.exists('/dev/rfcomm4'): 
    999                                 devices.append('/dev/rfcomm4') 
    1000                          
    1001                         if os.path.exists('/dev/ttyACM0'): 
    1002                                 devices.append('/dev/ttyACM0') 
    1003                         if os.path.exists('/dev/ttyACM1'): 
    1004                                 devices.append('/dev/ttyACM1') 
    1005                         if os.path.exists('/dev/ttyACM2'): 
    1006                                 devices.append('/dev/ttyACM2') 
    1007                         if os.path.exists('/dev/ttyACM3'): 
    1008                                 devices.append('/dev/ttyACM3') 
    1009                         if os.path.exists('/dev/ttyACM4'): 
    1010                                 devices.append('/dev/ttyACM4') 
    1011                  
    1012                  
    1013                 return(devices) 
    1014          
    1015          
    1016         ################################################################## 
    1017          
    1018         def hcitoolScanForRemoteDevices(self, devices=[]): 
    1019                  
    1020                 bluetooth_devices = [] 
    1021                  
    1022                 #command = '%s scan 2> /dev/null' % PATH_TO_HCITOOL 
    1023                 command = '%s scan' % PATH_TO_HCITOOL 
    1024                  
    1025                 if self.DEBUG > 1: 
    1026                         print 'INFO: Calling "%s"' % command  
    1027                  
    1028                 output = os.popen(command, 'r') 
    1029                  
    1030                 try: 
    1031                         result = output.readlines() 
    1032                 except Exception, e: 
    1033                         if self.DEBUG: 
    1034                                 print "ERROR [Synapse-Interface]: Failed reading result from call to hcitool:", 
    1035                                 print e 
    1036                         result = '' 
    1037                  
    1038                 if result == '': 
    1039                         return([]) # Under OS X hcitool doesn't exist so we don't see any devices 
    1040                  
    1041                 for line in result: 
    1042                         line = line.strip() 
    1043                         if line == '' or line == 'Scanning ...': 
    1044                                 continue 
    1045                         elif self.DEBUG > 1: 
    1046                                 print line 
    1047                         try: 
    1048                                 address = line.split('\t')[0] 
    1049                         except: 
    1050                                 pass 
    1051                         else: 
    1052                                 bluetooth_devices.append(address) 
    1053                  
    1054                  
    1055                 for address in bluetooth_devices: 
    1056                          
    1057                         command = '%s name %s' % (PATH_TO_HCITOOL, address) 
    1058                          
    1059                         if self.DEBUG: 
    1060                                 print 'INFO: Calling "%s"' % command 
    1061                          
    1062                         output = os.popen(command, 'r') 
    1063                          
    1064                         for line in output.readlines(): 
    1065                                 line = line.strip() 
    1066                                 if line == '': 
    1067                                         continue 
    1068                                 elif self.DEBUG: 
    1069                                         print '\t', 
    1070                                         print line 
    1071                                  
    1072                                 device_name = line.strip() 
    1073                          
    1074                                 if ((device_name == 'MindSet' or device_name == 'MindWave Mobile') and \ 
    1075                                         (address not in devices)): 
    1076                                         devices.append(address) 
    1077                                  
    1078                                 else: 
    1079                                         if self.DEBUG: 
    1080                                                 print 'INFO: Found but not recognized: [%s] %s' % \ 
    1081                                                         (address, device_name) 
    1082                  
    1083                  
    1084                 return (devices) 
    1085          
    1086          
    1087         ################################################################## 
    1088          
    1089         def hcitoolGetActiveConnections(self, devices=[]): 
    1090                  
    1091                 bluetooth_devices = [] 
    1092                  
    1093                 #command = '%s con 2> /dev/null' % PATH_TO_HCITOOL 
    1094                 command = '%s con' % PATH_TO_HCITOOL 
    1095                  
    1096                 if self.DEBUG > 1: 
    1097                         print 'INFO: Calling "%s"' % command  
    1098                  
    1099                 output = os.popen(command, 'r') 
    1100                  
    1101                 try: 
    1102                         result = output.readlines() 
    1103                 except Exception, e: 
    1104                         if self.DEBUG: 
    1105                                 print "ERROR [Synapse:Interface]: Failed reading result from call to hcitool:", 
    1106                                 print e 
    1107                         result = '' 
    1108  
    1109                 if result == '': 
    1110                         return([]) # Under OS X hcitool doesn't exist so we don't see any devices 
    1111  
    1112                 for line in result: 
    1113                         line = line.strip() 
    1114                         if line == '' or line == 'Connections:': 
    1115                                 continue 
    1116                         elif self.DEBUG > 1: 
    1117                                 print line 
    1118                         try: 
    1119                                 address = line.split(' ')[2] 
    1120                         except: 
    1121                                 pass 
    1122                         else: 
    1123                                 bluetooth_devices.append(address) 
    1124                  
    1125                  
    1126                 for address in bluetooth_devices: 
    1127                          
    1128                         command = '%s name %s' % (PATH_TO_HCITOOL, address) 
    1129                          
    1130                         if self.DEBUG: 
    1131                                 print 'INFO: Calling "%s":' % command 
    1132                          
    1133                         output = os.popen(command, 'r') 
    1134                          
    1135                         for line in output.readlines(): 
    1136                                 line = line.strip() 
    1137                                 if line == '': 
    1138                                         continue 
    1139                                 elif self.DEBUG: 
    1140                                         print '\t', 
    1141                                         print line 
    1142                                  
    1143                                 device_name = line.strip() 
    1144                          
    1145                                 if ((device_name == 'MindSet' or device_name == 'MindWave Mobile') and \ 
    1146                                         (address not in devices)): 
    1147                                         devices.append(address) 
    1148                  
    1149                  
    1150                 return (devices) 
    1151          
    1152          
    1153         ################################################################## 
    1154          
    1155         def searchForDevices(self): 
    1156                  
    1157                 enable_hcitool = configuration.ENABLE_HCITOOL 
    1158                  
    1159                 devices = [] 
    1160                  
    1161                 #self.pushButtonBluetoothSearch.setText('Searching') 
    1162                  
    1163                 if ((sys.platform != 'win32' and sys.platform != 'darwin') and \ 
    1164                      configuration.THINKGEAR_BLUETOOTH_SEARCH): 
    1165                          
    1166                         # Bluetooth module doesn't compile properly under Windows 
    1167                         # and doesn't exist under OS X 
    1168                          
    1169                         # PyBluez API Documentation 
    1170                         # http://pybluez.googlecode.com/svn/www/docs-0.7/index.html 
    1171                          
    1172                         bluetooth_devices = [] 
    1173                          
    1174                         if not enable_hcitool: 
    1175                                  
    1176                                 try: 
    1177                                          
    1178                                         if self.DEBUG: 
    1179                                                 print "INFO: Searching for Bluetooth devices using PyBluez module" 
    1180                                          
    1181                                         bluetooth_devices = bluetooth.discover_devices( \ 
    1182                                               duration=configuration.THINKGEAR_BLUETOOTH_DISCOVER_DEVICES_TIMEOUT, \ 
    1183                                                                flush_cache=True, \ 
    1184                                                                lookup_names=False) 
    1185                                          
    1186                                         for address in bluetooth_devices: 
    1187                                                  
    1188                                                 if self.DEBUG: 
    1189                                                         print "INFO: Device discovered", 
    1190                                                         print address 
    1191                                                  
    1192                                                 device_name = bluetooth.lookup_name(address, \ 
    1193                                                                  configuration.THINKGEAR_BLUETOOTH_LOOKUP_NAME_TIMEOUT) 
    1194                                                 if ((device_name == 'MindSet' or device_name == 'MindWave Mobile') and \ 
    1195                                                         (address not in devices)): 
    1196                                                         devices.append(address) 
    1197                                          
    1198                                          
    1199                                         # There is an issue under recent released of Linux 
    1200                                         # in which already-connected Bluetooth ThinkGear devices 
    1201                                         # are not appearing in a bluetooth device scan. However, 
    1202                                         # using "hcitool" connected devices can be listed correctly. 
    1203                                         # There does not appear to be an equivalent PyBluez feature. 
    1204                                         # (http://pybluez.googlecode.com/svn/www/docs-0.7/index.html) 
    1205                                          
    1206                                         if devices == []: 
    1207                                                 if self.DEBUG: 
    1208                                                         print "INFO: No devices found through PyBluez module. Falling back to hcitool." 
    1209                                                 devices = self.hcitoolGetActiveConnections(devices) 
    1210                                  
    1211                                  
    1212                                 except Exception, e: 
    1213                                         if self.DEBUG: 
    1214                                                 print "ERROR: Exception calling Python Bluetooth module. (Is PyBluez installed?):" 
    1215                                                 print e 
    1216                                          
    1217                                          
    1218                                         #if (sys.platform != 'darwin'): 
    1219                                         enable_hcitool = True 
    1220                          
    1221                          
    1222                         if enable_hcitool: 
    1223                                  
    1224                                 devices = self.hcitoolScanForRemoteDevices(devices) 
    1225                                 devices = self.hcitoolGetActiveConnections(devices) 
    1226                          
    1227                          
    1228                         if self.DEBUG > 2: 
    1229                                 print "Bluetooth Devices found:", 
    1230                                 print devices 
    1231                  
    1232                  
    1233                 devices = self.searchForSerialDevices(devices) 
    1234                  
    1235                  
    1236                 if self.DEBUG: 
    1237                         print "Devices found:", 
    1238                         print devices 
    1239                  
    1240                  
    1241                 return(devices) 
    1242          
    1243          
    1244         ################################################################## 
    1245          
    1246         def updateDevices(self): 
    1247                  
    1248                 model = self.comboBoxEEGHeadsetModel.currentText() 
    1249                  
    1250                 devices = self.searchForDevices() 
    1251                  
    1252                 self.comboBoxDeviceSelect.clear() 
    1253                  
    1254                 if (model == 'NeuroSky MindWave' or \ 
    1255                     model == 'NeuroSky MindSet' or \ 
    1256                     model == 'NeuroSky MindWave Mobile'): 
    1257                          
    1258                         devices.insert(0, 'ThinkGear Emulator') 
    1259                  
    1260                 elif (model == 'Emotiv EPOC'): 
    1261                          
    1262                         devices.insert(0, 'EmoComposer') 
    1263                         devices.insert(0, 'Emotiv Control Panel') 
    1264                  
    1265                  
    1266                 for device in devices: 
    1267                         self.comboBoxDeviceSelect.addItem(device) 
    1268          
    1269          
    1270         ################################################################## 
    1271          
    1272         def collectData(self, source=None, target=None): 
    1273                  
    1274                 if source == None: 
    1275                         if self.parent == None: 
    1276                                 source = self 
    1277                         else: 
    1278                                 source = self.parent 
    1279                  
    1280                 if target == None: 
    1281                         if self.parent == None: 
    1282                                 target = self 
    1283                         else: 
    1284                                 target = self.parent 
    1285                  
    1286                 data = {} 
    1287                  
    1288                 data['rawEeg'] = source.packets['rawEeg'] 
    1289                 data['signals'] = source.packets['signals'] 
    1290                  
    1291                 data['sessionTime'] = self.calculateSessionTime() 
    1292                  
    1293                 data['profileName'] = str(target.lineEditSessionProfile.text()) 
    1294                  
    1295                 return(data) 
    1296          
    1297          
    1298         ################################################################## 
    1299          
    1300         def parseTimeStamp(self, timestamp, local_version=False, truncate_time_zone=False): 
    1301                  
    1302                 try: 
    1303                         decimal = '%f' % timestamp 
    1304                         decimal = decimal.split('.')[1] 
    1305                 except: 
    1306                         decimal = '0' 
    1307                  
    1308                 localtime = time.localtime(timestamp) 
    1309                  
    1310                 if local_version: 
    1311                         date = time.strftime('%x', localtime) 
    1312                         localtime = time.strftime('%X', localtime) 
    1313                  
    1314                 elif truncate_time_zone: 
    1315                         date = time.strftime('%Y-%m-%d', localtime) 
    1316                         localtime = time.strftime('%H:%M:%S', localtime) 
    1317                         localtime = '%s.%s' % (localtime, decimal[:3]) 
    1318                  
    1319                 else: 
    1320                         date = time.strftime('%Y-%m-%d', localtime) 
    1321                         localtime = time.strftime('%H:%M:%S', localtime) 
    1322                         localtime = '%s.%s %s' % (localtime, decimal, \ 
    1323                                        time.strftime('%Z', time.localtime(timestamp))) 
    1324                  
    1325                  
    1326                 return(date, localtime) 
    1327          
    1328          
    1329         ################################################################## 
    1330          
    1331         def saveData(self, source=None, target=None, output_file=None, use_default=False): 
    1332                  
    1333                 if source == None: 
    1334                         if self.parent == None: 
    1335                                 source = self 
    1336                         else: 
    1337                                 source = self.parent 
    1338                  
    1339                 if target == None: 
    1340                         if self.parent == None: 
    1341                                 target = self 
    1342                         else: 
    1343                                 target = self.parent 
    1344                  
    1345                 data = self.collectData(source=source, target=target) 
    1346                  
    1347                 (date, localtime) = self.parseTimeStamp(time.time()) 
    1348                  
    1349                 default_filename = '%s %s.synapse' % (date, \ 
    1350                                       target.lineEditSessionProfile.text()) 
    1351                                        
    1352                 default_filename = os.path.join(self.homepath, default_filename) 
    1353                  
    1354                 if output_file == None: 
    1355                          
    1356                         # use_default controls whether or not a file is automatically saves using the 
    1357                         # default name and path (as opposed to raising a GUI file selection menu) 
    1358                         # whenever an explicit filepath is not defined 
    1359                         if use_default: 
    1360                                          
    1361                                         output_file = default_filename 
    1362                          
    1363                         else: 
    1364                          
    1365                                 output_file = QtGui.QFileDialog.getSaveFileName(parent=target, \ 
    1366                                                  caption="Save Session Data to File", \ 
    1367                                                  dir=default_filename, \ 
    1368                                                  filter="Puzzlebox Synapse Data File (*.synapse)") 
    1369                                  
    1370                                 try: 
    1371                                         output_file = output_file[0] 
    1372                                 except: 
    1373                                         output_file = '' 
    1374                  
    1375                  
    1376                 if output_file == '': 
    1377                         return 
    1378                  
    1379                 file = open(str(output_file), 'w') 
    1380                 pickle.dump(data, file) 
    1381                 file.close() 
    1382          
    1383          
    1384         ################################################################## 
    1385          
    1386         def exportData(self, parent=None, source=None, target=None, output_file=None, use_default=False): 
    1387                  
    1388                 if parent == None: 
    1389                         if self.parent == None: 
    1390                                 parent = self 
    1391                         else: 
    1392                                 parent = self.parent 
    1393                  
    1394                 if source == None: 
    1395                         if self.parent == None: 
    1396                                 source = self 
    1397                         else: 
    1398                                 source = self.parent 
    1399                  
    1400                 if target == None: 
    1401                         if self.parent == None: 
    1402                                 target = self 
    1403                         else: 
    1404                                 target = self.parent 
    1405                  
    1406                  
    1407                 (date, localtime) = self.parseTimeStamp(time.time()) 
    1408                  
    1409                 default_filename = '%s %s.csv' % (date, \ 
    1410                                       target.lineEditSessionProfile.text()) 
    1411                  
    1412                 default_filename = os.path.join(target.homepath, default_filename) 
    1413                  
    1414                  
    1415                 if output_file == None: 
    1416                          
    1417                         # use_default controls whether or not a file is automatically saves using the 
    1418                         # default name and path (as opposed to raising a GUI file selection menu) 
    1419                         # whenever an explicit filepath is not defined 
    1420                         if use_default: 
    1421                                          
    1422                                         output_file = default_filename 
    1423                          
    1424                         else: 
    1425                                 output_file = QtGui.QFileDialog.getSaveFileName(parent=target, \ 
    1426                                                  caption="Export Session Data to File", \ 
    1427                                                  dir=default_filename, \ 
    1428                                                  filter="CSV File (*.csv);;Text File (*.txt)") 
    1429                                  
    1430                                 try: 
    1431                                         output_file = output_file[0] 
    1432                                 except: 
    1433                                         output_file = '' 
    1434                  
    1435                  
    1436                 if output_file == '': 
    1437                         return 
    1438                  
    1439                  
    1440                 if str(output_file).endswith('.csv'): 
    1441                          
    1442                         outputData = self.exportDataToCSV(parent=parent, source=source, target=target) 
    1443                  
    1444                  
    1445                 else: 
    1446                          
    1447                         try: 
    1448                                 outputData = self.textEditDebugConsole.toPlainText() 
    1449                         except: 
    1450                                 outputData = self.exportDataToCSV() 
    1451                  
    1452                  
    1453                 file = open(str(output_file), 'w') 
    1454                 file.write(outputData) 
    1455                 file.close() 
    1456          
    1457          
    1458         ################################################################## 
    1459          
    1460         def exportDataToCSV(self, parent=None, source=None, target=None): 
    1461                  
    1462                 if parent == None: 
    1463                         if self.parent == None: 
    1464                                 parent = self 
    1465                         else: 
    1466                                 parent = self.parent 
    1467                  
    1468                 if source == None: 
    1469                         if self.parent == None: 
    1470                                 source = self 
    1471                         else: 
    1472                                 source = self.parent 
    1473                  
    1474                 if target == None: 
    1475                         if self.parent == None: 
    1476                                 target = self 
    1477                         else: 
    1478                                 target = self.parent 
    1479                  
    1480                 try: 
    1481                         truncate_csv_timezone = target.configuration.EXPORT_CSV_TRUNCATE_TIMEZONE 
    1482                 except: 
    1483                         truncate_csv_timezone = False 
    1484                  
    1485                 try: 
    1486                         scrub_data = target.configuration.EXPORT_CSV_SCRUB_DATA 
    1487                 except: 
    1488                         scrub_data = False 
    1489                  
    1490                  
    1491                 headers = 'Date,Time,Attention,Meditation,Signal Level,Delta,Theta,Low Alpha,High Alpha,Low Beta,High Beta,Low Gamma,Mid Gamma' 
    1492                  
    1493                 customDataHeaders = [] 
    1494                 for header in parent.customDataHeaders: 
    1495                         customDataHeaders.append(header) 
    1496                 for plugin in parent.activePlugins: 
    1497                         for header in plugin.customDataHeaders: 
    1498                                 customDataHeaders.append(header) 
    1499                  
    1500                 for each in customDataHeaders: 
    1501                         headers = headers + ',%s' % each 
    1502                  
    1503                 headers = headers + '\n' 
    1504                  
    1505                 csv = {} 
    1506                  
    1507                 for packet in source.packets['signals']: 
    1508                          
    1509                          
    1510                         if 'rawEeg' in packet.keys(): 
    1511                                 continue 
    1512                          
    1513                         if packet['timestamp'] not in csv.keys(): 
    1514                                  
    1515                                 if 'blinkStrength' in packet.keys(): 
    1516                                         # Skip any blink packets from log 
    1517                                         continue 
    1518                                  
    1519                                  
    1520                                 #print packet 
    1521                                 timestamp = packet['timestamp'] 
    1522                                 (date, localtime) = self.parseTimeStamp(timestamp, \ 
    1523                                                     truncate_time_zone=truncate_csv_timezone) 
    1524                                  
    1525                                 csv[timestamp] = {} 
    1526                                 csv[timestamp]['Date'] = date 
    1527                                 csv[timestamp]['Time'] = localtime 
    1528                                 csv[timestamp]['Attention'] = '' 
    1529                                 csv[timestamp]['Meditation'] = '' 
    1530                                 csv[timestamp]['Signal Level'] = '' 
    1531                                 csv[timestamp]['Delta'] = '' 
    1532                                 csv[timestamp]['Theta'] = '' 
    1533                                 csv[timestamp]['Low Alpha'] = '' 
    1534                                 csv[timestamp]['High Alpha'] = '' 
    1535                                 csv[timestamp]['Low Beta'] = '' 
    1536                                 csv[timestamp]['High Beta'] = '' 
    1537                                 csv[timestamp]['Low Gamma'] = '' 
    1538                                 csv[timestamp]['Mid Gamma'] = '' 
    1539                                  
    1540                                 for header in customDataHeaders: 
    1541                                         csv[timestamp][header] = '' 
    1542                          
    1543                          
    1544                         if 'eSense' in packet.keys(): 
    1545                                 if 'attention' in packet['eSense'].keys(): 
    1546                                         csv[timestamp]['Attention'] = packet['eSense']['attention'] 
    1547                                 if 'meditation' in packet['eSense'].keys(): 
    1548                                         csv[timestamp]['Meditation'] = packet['eSense']['meditation'] 
    1549                          
    1550                         if 'eegPower' in packet.keys(): 
    1551                                 if 'delta' in packet['eegPower'].keys(): 
    1552                                         csv[timestamp]['Delta'] = packet['eegPower']['delta'] 
    1553                                 if 'theta' in packet['eegPower'].keys(): 
    1554                                         csv[timestamp]['Theta'] = packet['eegPower']['theta'] 
    1555                                 if 'lowAlpha' in packet['eegPower'].keys(): 
    1556                                         csv[timestamp]['Low Alpha'] = packet['eegPower']['lowAlpha'] 
    1557                                 if 'highAlpha' in packet['eegPower'].keys(): 
    1558                                         csv[timestamp]['High Alpha'] = packet['eegPower']['highAlpha'] 
    1559                                 if 'lowBeta' in packet['eegPower'].keys(): 
    1560                                         csv[timestamp]['Low Beta'] = packet['eegPower']['lowBeta'] 
    1561                                 if 'highBeta' in packet['eegPower'].keys(): 
    1562                                         csv[timestamp]['High Beta'] = packet['eegPower']['highBeta'] 
    1563                                 if 'lowGamma' in packet['eegPower'].keys(): 
    1564                                         csv[timestamp]['Low Gamma'] = packet['eegPower']['lowGamma'] 
    1565                                 if 'highGamma' in packet['eegPower'].keys(): 
    1566                                         csv[timestamp]['Mid Gamma'] = packet['eegPower']['highGamma'] 
    1567                          
    1568                         if 'poorSignalLevel' in packet.keys(): 
    1569                                 csv[timestamp]['Signal Level'] = packet['poorSignalLevel'] 
    1570                          
    1571                         for header in customDataHeaders: 
    1572                                 if 'custom' in packet.keys() and \ 
    1573                                    header in packet['custom'].keys(): 
    1574                                         csv[timestamp][header] = packet['custom'][header] 
    1575                  
    1576                  
    1577                 if scrub_data: 
    1578                         csv = self.scrubData(csv, truncate_csv_timezone) 
    1579                  
    1580                  
    1581                 output = headers 
    1582                  
    1583                 csv_keys = csv.keys() 
    1584                 csv_keys.sort() 
    1585                  
    1586                 for key in csv_keys: 
    1587                          
    1588                         row = '%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s' % \ 
    1589                               (csv[key]['Date'], \ 
    1590                                csv[key]['Time'], \ 
    1591                                csv[key]['Attention'], \ 
    1592                                csv[key]['Meditation'], \ 
    1593                                csv[key]['Signal Level'], \ 
    1594                                csv[key]['Delta'], \ 
    1595                                csv[key]['Theta'], \ 
    1596                                csv[key]['Low Alpha'], \ 
    1597                                csv[key]['High Alpha'], \ 
    1598                                csv[key]['Low Beta'], \ 
    1599                                csv[key]['High Beta'], \ 
    1600                                csv[key]['Low Gamma'], \ 
    1601                                csv[key]['Mid Gamma']) 
    1602                          
    1603                         for header in customDataHeaders: 
    1604                                 row = row + ',%s' % csv[key][header] 
    1605                          
    1606                         row = row + '\n' 
    1607                          
    1608                         output = output + row 
    1609                  
    1610                  
    1611                 return(output) 
    1612          
    1613          
    1614         ################################################################## 
    1615          
    1616         def scrubData(self, csv, truncate_csv_timezone=False): 
    1617                  
    1618                 # If there are missing packets, repeat a given packet once per missing 
    1619                 # second until there is a gap between 1 and 2 seconds, in which case 
    1620                 # produce a final duplicate packet at the mid-point between the packets 
    1621  
    1622                 if self.DEBUG: 
    1623                         print "INFO: Scrubbing Data" 
    1624                  
    1625                 last_time = None 
    1626                 last_recorded_time = None 
    1627                  
    1628                 output = {} 
    1629                  
    1630                 csv_keys = csv.keys() 
    1631                 csv_keys.sort() 
    1632                  
    1633                 for key in csv_keys: 
    1634                          
    1635                         timestamp = key 
    1636  
    1637                         if csv[key]['Attention'] == '': 
    1638                                 continue 
    1639                          
    1640                         if last_time == None: 
    1641                                 # First entry in log 
    1642                                 last_time = timestamp 
    1643                                 last_recorded_time = timestamp 
    1644                                 output[key] = csv[key] 
    1645                                 continue 
    1646                          
    1647                         else: 
    1648                                  
    1649                                 #time_difference = timestamp - last_time 
    1650                                 time_difference = timestamp - last_recorded_time 
    1651                                  
    1652                                 if (time_difference <= 1) and \ 
    1653                                    (time_difference >= PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD): 
    1654                                         # Skip packets within the correct time threshold 
    1655                                         last_time = timestamp 
    1656                                         last_recorded_time = timestamp 
    1657                                         output[key] = csv[key] 
    1658                                         continue 
    1659                                  
    1660                                 else: 
    1661                                          
    1662                                         if self.DEBUG > 1: 
    1663                                                 print "time_difference:", 
    1664                                                 print time_difference 
    1665                                                 print "timestamp:", 
    1666                                                 print self.parseTimeStamp(timestamp)[-1].split(' ')[0] 
    1667                                                 print "last_time:", 
    1668                                                 print self.parseTimeStamp(last_time)[-1].split(' ')[0] 
    1669                                                 print "last_recorded_time:", 
    1670                                                 print self.parseTimeStamp(last_recorded_time)[-1].split(' ')[0] 
    1671                                          
    1672                                          
    1673                                         new_packet = csv[key].copy() 
    1674                                          
    1675                                         if time_difference >= 2: 
    1676                                                  
    1677                                                 ##new_time = last_time + 1 
    1678                                                 #new_time = last_recorded_time + 1 
    1679                                                  
    1680                                                 count = int(time_difference) 
    1681                                                 while count >= 1: 
    1682                                                         new_packet = csv[key].copy() 
    1683                                                         new_time = last_recorded_time + 1 
    1684                                                         (date, formatted_new_time) = self.parseTimeStamp(new_time, \ 
    1685                                                          truncate_time_zone=truncate_csv_timezone) 
    1686                                                         new_packet['Time'] = formatted_new_time 
    1687                                                         last_recorded_time = new_time 
    1688                                                         last_time = timestamp 
    1689                                                         output[new_time] = new_packet 
    1690                                                         count = count - 1 
    1691                                                 continue 
    1692                                                  
    1693                                         elif time_difference < PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD: 
    1694                                                 # Spread out "bunched up" packets 
    1695                                                 #new_time = last_time + 1 
    1696                                                 new_time = last_recorded_time + 1 
    1697                                          
    1698                                          
    1699                                         elif (time_difference < 2) and (time_difference > 1): 
    1700                                                  
    1701                                                 #new_time = last_time + ((last_time - timestamp) / 2) 
    1702                                                 #new_time = last_recorded_time + ((last_recorded_time - timestamp) / 2) 
    1703                                                 #new_time = last_time + 1 
    1704                                                 new_time = last_recorded_time + 1 
    1705                                          
    1706                                          
    1707                                         (date, formatted_new_time) = self.parseTimeStamp(new_time, \ 
    1708                                            truncate_time_zone=truncate_csv_timezone) 
    1709                                          
    1710                                         new_packet['Time'] = formatted_new_time 
    1711                                          
    1712                                         #last_time = new_time 
    1713                                         last_recorded_time = new_time 
    1714                                         last_time = timestamp 
    1715                                         output[new_time] = new_packet 
    1716                                          
    1717                                         if self.DEBUG > 1: 
    1718                                                 print "WARN: Scrubbing new packet:", 
    1719                                                 print new_packet 
    1720                                                 print 
    1721                  
    1722                  
    1723                 return(output) 
    1724          
    1725          
    1726         ################################################################## 
    1727          
    1728         def resetData(self, source=None): 
    1729                  
    1730                 if source == None: 
    1731                         if self.parent == None: 
    1732                                 source = self 
    1733                         else: 
    1734                                 source = self.parent 
     779        #def updateProfileSessionStatus(self, source=None, target=None): 
     780                 
     781                #session_time = self.calculateSessionTime() 
     782                 
     783                #if source == None: 
     784                        #if self.parent == None: 
     785                                #source = self 
     786                        #else: 
     787                                #source = self.parent 
    1735788                 
    1736789                #if target == None: 
     
    1740793                                #target = self.parent 
    1741794                 
    1742                 source.packets['rawEeg'] = [] 
    1743                 source.packets['signals'] = [] 
    1744                  
    1745                 source.synapseServer.protocol.session_start_timestamp = \ 
    1746                         time.time() 
    1747                  
    1748                 source.synapseServer.protocol.packet_count = 0 
    1749                 source.synapseServer.protocol.bad_packets = 0 
    1750                  
    1751                 self.updateProfileSessionStatus() 
    1752                  
    1753                 try: 
    1754                         source.textEditDebugConsole.setText("") 
    1755                 except: 
    1756                         pass 
     795                #target.textLabelSessionTime.setText(session_time) 
     796                 
     797                #try: 
     798                        #target.textLabelPacketsReceived.setText( "%i" % \ 
     799                                #source.synapseServer.protocol.packet_count) 
     800                #except: 
     801                        #pass 
     802                 
     803                #try: 
     804                        #target.textLabelPacketsDropped.setText( "%i" % \ 
     805                                #source.synapseServer.protocol.bad_packets) 
     806                #except: 
     807                        #pass 
     808         
     809         
     810        ################################################################## 
     811         
     812        #def calculateSessionTime(self): 
     813                 
     814                #if self.parent == None: 
     815                        #server = self.synapseServer 
     816                #else: 
     817                        #server = self.parent.synapseServer 
     818                 
     819                #session_time = time.time() - \ 
     820                        #server.session_start_timestamp 
     821                        ##server.protocol.session_start_timestamp 
     822                 
     823                #session_time = int(session_time) 
     824                 
     825                #session_time = self.convert_seconds_to_datetime(session_time) 
     826                 
     827                #return(session_time) 
     828         
     829         
     830        ################################################################## 
     831         
     832        #def enumerateSerialPorts(self): 
     833                 
     834                #""" Uses the Win32 registry to return an 
     835                #iterator of serial (COM) ports 
     836                #existing on this computer. 
     837                 
     838                #from http://eli.thegreenplace.net/2009/07/31/listing-all-serial-ports-on-windows-with-python/ 
     839                #""" 
     840          
     841                #path = 'HARDWARE\\DEVICEMAP\\SERIALCOMM' 
     842                #try: 
     843                        #key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path) 
     844                #except WindowsError: 
     845                        ##raise IterationError 
     846                        #return 
     847                 
     848                #for i in itertools.count(): 
     849                        #try: 
     850                                #val = winreg.EnumValue(key, i) 
     851                                #yield str(val[1]) 
     852                        #except EnvironmentError: 
     853                                #break 
     854         
     855         
     856        ################################################################## 
     857         
     858        #def fullPortName(self, portname): 
     859                 
     860                #""" Given a port-name (of the form COM7, 
     861                #COM12, CNCA0, etc.) returns a full 
     862                #name suitable for opening with the 
     863                #Serial class. 
     864                #""" 
     865                 
     866                #m = re.match('^COM(\d+)$', portname) 
     867                #if m and int(m.group(1)) < 10: 
     868                        #return portname 
     869                 
     870                #return '\\\\.\\' + portname 
     871         
     872         
     873        ################################################################## 
     874         
     875        #def searchForSerialDevices(self, devices=[]): 
     876                 
     877                #if (sys.platform == 'win32'): 
     878                         
     879                        #for portname in self.enumerateSerialPorts(): 
     880                                 
     881                                #if portname not in devices: 
     882                                        ##portname = self.fullPortName(portname) 
     883                                        #devices.append(portname) 
     884                 
     885                #else: 
     886                         
     887                         
     888                        #if os.path.exists('/dev/tty.MindWaveMobile-SPPDev'): 
     889                                #devices.append('/dev/tty.MindWaveMobile-SPPDev') 
     890                         
     891                        #if os.path.exists('/dev/tty.MindWave'): 
     892                                #devices.append('/dev/tty.MindWave') 
     893                        #if os.path.exists('/dev/tty.MindWave1'): 
     894                                #devices.append('/dev/tty.MindWave1') 
     895                        #if os.path.exists('/dev/tty.MindWave2'): 
     896                                #devices.append('/dev/tty.MindWave2') 
     897                        #if os.path.exists('/dev/tty.MindWave3'): 
     898                                #devices.append('/dev/tty.MindWave3') 
     899                        #if os.path.exists('/dev/tty.MindWave4'): 
     900                                #devices.append('/dev/tty.MindWave4') 
     901                        #if os.path.exists('/dev/tty.MindWave5'): 
     902                                #devices.append('/dev/tty.MindWave5') 
     903                         
     904                        #if os.path.exists('/dev/tty.MindSet-DevB'): 
     905                                #devices.append('/dev/tty.MindSet-DevB') 
     906                         
     907                        #if os.path.exists('/dev/ttyUSB0'): 
     908                                #devices.append('/dev/ttyUSB0') 
     909                        #if os.path.exists('/dev/ttyUSB1'): 
     910                                #devices.append('/dev/ttyUSB1') 
     911                        #if os.path.exists('/dev/ttyUSB2'): 
     912                                #devices.append('/dev/ttyUSB2') 
     913                        #if os.path.exists('/dev/ttyUSB3'): 
     914                                #devices.append('/dev/ttyUSB3') 
     915                        #if os.path.exists('/dev/ttyUSB4'): 
     916                                #devices.append('/dev/ttyUSB4') 
     917                        #if os.path.exists('/dev/ttyUSB5'): 
     918                                #devices.append('/dev/ttyUSB5') 
     919                        #if os.path.exists('/dev/ttyUSB6'): 
     920                                #devices.append('/dev/ttyUSB6') 
     921                        #if os.path.exists('/dev/ttyUSB7'): 
     922                                #devices.append('/dev/ttyUSB7') 
     923                        #if os.path.exists('/dev/ttyUSB8'): 
     924                                #devices.append('/dev/ttyUSB8') 
     925                        #if os.path.exists('/dev/ttyUSB9'): 
     926                                #devices.append('/dev/ttyUSB9') 
     927                         
     928                        #if os.path.exists('/dev/rfcomm0'): 
     929                                #devices.append('/dev/rfcomm0') 
     930                        #if os.path.exists('/dev/rfcomm1'): 
     931                                #devices.append('/dev/rfcomm1') 
     932                        #if os.path.exists('/dev/rfcomm2'): 
     933                                #devices.append('/dev/rfcomm2') 
     934                        #if os.path.exists('/dev/rfcomm3'): 
     935                                #devices.append('/dev/rfcomm3') 
     936                        #if os.path.exists('/dev/rfcomm4'): 
     937                                #devices.append('/dev/rfcomm4') 
     938                         
     939                        #if os.path.exists('/dev/ttyACM0'): 
     940                                #devices.append('/dev/ttyACM0') 
     941                        #if os.path.exists('/dev/ttyACM1'): 
     942                                #devices.append('/dev/ttyACM1') 
     943                        #if os.path.exists('/dev/ttyACM2'): 
     944                                #devices.append('/dev/ttyACM2') 
     945                        #if os.path.exists('/dev/ttyACM3'): 
     946                                #devices.append('/dev/ttyACM3') 
     947                        #if os.path.exists('/dev/ttyACM4'): 
     948                                #devices.append('/dev/ttyACM4') 
     949                 
     950                 
     951                #return(devices) 
     952         
     953         
     954        ################################################################## 
     955         
     956        #def hcitoolScanForRemoteDevices(self, devices=[]): 
     957                 
     958                #bluetooth_devices = [] 
     959                 
     960                ##command = '%s scan 2> /dev/null' % PATH_TO_HCITOOL 
     961                #command = '%s scan' % PATH_TO_HCITOOL 
     962                 
     963                #if self.DEBUG > 1: 
     964                        #print 'INFO: Calling "%s"' % command  
     965                 
     966                #output = os.popen(command, 'r') 
     967                 
     968                #try: 
     969                        #result = output.readlines() 
     970                #except Exception, e: 
     971                        #if self.DEBUG: 
     972                                #print "ERROR [Synapse-Interface]: Failed reading result from call to hcitool:", 
     973                                #print e 
     974                        #result = '' 
     975                 
     976                #if result == '': 
     977                        #return([]) # Under OS X hcitool doesn't exist so we don't see any devices 
     978                 
     979                #for line in result: 
     980                        #line = line.strip() 
     981                        #if line == '' or line == 'Scanning ...': 
     982                                #continue 
     983                        #elif self.DEBUG > 1: 
     984                                #print line 
     985                        #try: 
     986                                #address = line.split('\t')[0] 
     987                        #except: 
     988                                #pass 
     989                        #else: 
     990                                #bluetooth_devices.append(address) 
     991                 
     992                 
     993                #for address in bluetooth_devices: 
     994                         
     995                        #command = '%s name %s' % (PATH_TO_HCITOOL, address) 
     996                         
     997                        #if self.DEBUG: 
     998                                #print 'INFO: Calling "%s"' % command 
     999                         
     1000                        #output = os.popen(command, 'r') 
     1001                         
     1002                        #for line in output.readlines(): 
     1003                                #line = line.strip() 
     1004                                #if line == '': 
     1005                                        #continue 
     1006                                #elif self.DEBUG: 
     1007                                        #print '\t', 
     1008                                        #print line 
     1009                                 
     1010                                #device_name = line.strip() 
     1011                         
     1012                                #if ((device_name == 'MindSet' or device_name == 'MindWave Mobile') and \ 
     1013                                        #(address not in devices)): 
     1014                                        #devices.append(address) 
     1015                                 
     1016                                #else: 
     1017                                        #if self.DEBUG: 
     1018                                                #print 'INFO: Found but not recognized: [%s] %s' % \ 
     1019                                                        #(address, device_name) 
     1020                 
     1021                 
     1022                #return (devices) 
     1023         
     1024         
     1025        ################################################################## 
     1026         
     1027        #def hcitoolGetActiveConnections(self, devices=[]): 
     1028                 
     1029                #bluetooth_devices = [] 
     1030                 
     1031                ##command = '%s con 2> /dev/null' % PATH_TO_HCITOOL 
     1032                #command = '%s con' % PATH_TO_HCITOOL 
     1033                 
     1034                #if self.DEBUG > 1: 
     1035                        #print 'INFO: Calling "%s"' % command  
     1036                 
     1037                #output = os.popen(command, 'r') 
     1038                 
     1039                #try: 
     1040                        #result = output.readlines() 
     1041                #except Exception, e: 
     1042                        #if self.DEBUG: 
     1043                                #print "ERROR [Synapse:Interface]: Failed reading result from call to hcitool:", 
     1044                                #print e 
     1045                        #result = '' 
     1046 
     1047                #if result == '': 
     1048                        #return([]) # Under OS X hcitool doesn't exist so we don't see any devices 
     1049 
     1050                #for line in result: 
     1051                        #line = line.strip() 
     1052                        #if line == '' or line == 'Connections:': 
     1053                                #continue 
     1054                        #elif self.DEBUG > 1: 
     1055                                #print line 
     1056                        #try: 
     1057                                #address = line.split(' ')[2] 
     1058                        #except: 
     1059                                #pass 
     1060                        #else: 
     1061                                #bluetooth_devices.append(address) 
     1062                 
     1063                 
     1064                #for address in bluetooth_devices: 
     1065                         
     1066                        #command = '%s name %s' % (PATH_TO_HCITOOL, address) 
     1067                         
     1068                        #if self.DEBUG: 
     1069                                #print 'INFO: Calling "%s":' % command 
     1070                         
     1071                        #output = os.popen(command, 'r') 
     1072                         
     1073                        #for line in output.readlines(): 
     1074                                #line = line.strip() 
     1075                                #if line == '': 
     1076                                        #continue 
     1077                                #elif self.DEBUG: 
     1078                                        #print '\t', 
     1079                                        #print line 
     1080                                 
     1081                                #device_name = line.strip() 
     1082                         
     1083                                #if ((device_name == 'MindSet' or device_name == 'MindWave Mobile') and \ 
     1084                                        #(address not in devices)): 
     1085                                        #devices.append(address) 
     1086                 
     1087                 
     1088                #return (devices) 
     1089         
     1090         
     1091        ################################################################## 
     1092         
     1093        #def searchForDevices(self): 
     1094                 
     1095                #enable_hcitool = configuration.ENABLE_HCITOOL 
     1096                 
     1097                #devices = [] 
     1098                 
     1099                ##self.pushButtonBluetoothSearch.setText('Searching') 
     1100                 
     1101                #if ((sys.platform != 'win32' and sys.platform != 'darwin') and \ 
     1102                     #configuration.THINKGEAR_BLUETOOTH_SEARCH): 
     1103                         
     1104                        ## Bluetooth module doesn't compile properly under Windows 
     1105                        ## and doesn't exist under OS X 
     1106                         
     1107                        ## PyBluez API Documentation 
     1108                        ## http://pybluez.googlecode.com/svn/www/docs-0.7/index.html 
     1109                         
     1110                        #bluetooth_devices = [] 
     1111                         
     1112                        #if not enable_hcitool: 
     1113                                 
     1114                                #try: 
     1115                                         
     1116                                        #if self.DEBUG: 
     1117                                                #print "INFO: Searching for Bluetooth devices using PyBluez module" 
     1118                                         
     1119                                        #bluetooth_devices = bluetooth.discover_devices( \ 
     1120                                              #duration=configuration.THINKGEAR_BLUETOOTH_DISCOVER_DEVICES_TIMEOUT, \ 
     1121                                                               #flush_cache=True, \ 
     1122                                                               #lookup_names=False) 
     1123                                         
     1124                                        #for address in bluetooth_devices: 
     1125                                                 
     1126                                                #if self.DEBUG: 
     1127                                                        #print "INFO: Device discovered", 
     1128                                                        #print address 
     1129                                                 
     1130                                                #device_name = bluetooth.lookup_name(address, \ 
     1131                                                                 #configuration.THINKGEAR_BLUETOOTH_LOOKUP_NAME_TIMEOUT) 
     1132                                                #if ((device_name == 'MindSet' or device_name == 'MindWave Mobile') and \ 
     1133                                                        #(address not in devices)): 
     1134                                                        #devices.append(address) 
     1135                                         
     1136                                         
     1137                                        ## There is an issue under recent released of Linux 
     1138                                        ## in which already-connected Bluetooth ThinkGear devices 
     1139                                        ## are not appearing in a bluetooth device scan. However, 
     1140                                        ## using "hcitool" connected devices can be listed correctly. 
     1141                                        ## There does not appear to be an equivalent PyBluez feature. 
     1142                                        ## (http://pybluez.googlecode.com/svn/www/docs-0.7/index.html) 
     1143                                         
     1144                                        #if devices == []: 
     1145                                                #if self.DEBUG: 
     1146                                                        #print "INFO: No devices found through PyBluez module. Falling back to hcitool." 
     1147                                                #devices = self.hcitoolGetActiveConnections(devices) 
     1148                                 
     1149                                 
     1150                                #except Exception, e: 
     1151                                        #if self.DEBUG: 
     1152                                                #print "ERROR: Exception calling Python Bluetooth module. (Is PyBluez installed?):" 
     1153                                                #print e 
     1154                                         
     1155                                         
     1156                                        ##if (sys.platform != 'darwin'): 
     1157                                        #enable_hcitool = True 
     1158                         
     1159                         
     1160                        #if enable_hcitool: 
     1161                                 
     1162                                #devices = self.hcitoolScanForRemoteDevices(devices) 
     1163                                #devices = self.hcitoolGetActiveConnections(devices) 
     1164                         
     1165                         
     1166                        #if self.DEBUG > 2: 
     1167                                #print "Bluetooth Devices found:", 
     1168                                #print devices 
     1169                 
     1170                 
     1171                #devices = self.searchForSerialDevices(devices) 
     1172                 
     1173                 
     1174                #if self.DEBUG: 
     1175                        #print "Devices found:", 
     1176                        #print devices 
     1177                 
     1178                 
     1179                #return(devices) 
     1180         
     1181         
     1182        ################################################################## 
     1183         
     1184        def updateDevices(self): 
     1185                 
     1186                if (self.parent != None): 
     1187                        source = self.parent 
     1188                else: 
     1189                        source = self 
     1190                 
     1191                model = source.comboBoxEEGHeadsetModel.currentText() 
     1192                 
     1193                devices = self.searchForDevices() 
     1194                 
     1195                source.comboBoxDeviceSelect.clear() 
     1196                 
     1197                if (model == 'NeuroSky MindWave' or \ 
     1198                    model == 'NeuroSky MindSet' or \ 
     1199                    model == 'NeuroSky MindWave Mobile'): 
     1200                         
     1201                        devices.insert(0, 'ThinkGear Emulator') 
     1202                 
     1203                elif (model == 'Emotiv EPOC'): 
     1204                         
     1205                        devices.insert(0, 'EmoComposer') 
     1206                        devices.insert(0, 'Emotiv Control Panel') 
     1207                 
     1208                 
     1209                for device in devices: 
     1210                        source.comboBoxDeviceSelect.addItem(device) 
     1211         
     1212         
     1213        ################################################################## 
     1214         
     1215        #def collectData(self, source=None, target=None): 
     1216                 
     1217                #if source == None: 
     1218                        #if self.parent == None: 
     1219                                #source = self 
     1220                        #else: 
     1221                                #source = self.parent 
     1222                 
     1223                #if target == None: 
     1224                        #if self.parent == None: 
     1225                                #target = self 
     1226                        #else: 
     1227                                #target = self.parent 
     1228                 
     1229                #data = {} 
     1230                 
     1231                #data['rawEeg'] = source.packets['rawEeg'] 
     1232                #data['signals'] = source.packets['signals'] 
     1233                 
     1234                #data['sessionTime'] = self.calculateSessionTime() 
     1235                 
     1236                #data['profileName'] = str(target.lineEditSessionProfile.text()) 
     1237                 
     1238                #return(data) 
     1239         
     1240         
     1241        ################################################################## 
     1242         
     1243        #def parseTimeStamp(self, timestamp, local_version=False, truncate_time_zone=False): 
     1244                 
     1245                #try: 
     1246                        #decimal = '%f' % timestamp 
     1247                        #decimal = decimal.split('.')[1] 
     1248                #except: 
     1249                        #decimal = '0' 
     1250                 
     1251                #localtime = time.localtime(timestamp) 
     1252                 
     1253                #if local_version: 
     1254                        #date = time.strftime('%x', localtime) 
     1255                        #localtime = time.strftime('%X', localtime) 
     1256                 
     1257                #elif truncate_time_zone: 
     1258                        #date = time.strftime('%Y-%m-%d', localtime) 
     1259                        #localtime = time.strftime('%H:%M:%S', localtime) 
     1260                        #localtime = '%s.%s' % (localtime, decimal[:3]) 
     1261                 
     1262                #else: 
     1263                        #date = time.strftime('%Y-%m-%d', localtime) 
     1264                        #localtime = time.strftime('%H:%M:%S', localtime) 
     1265                        #localtime = '%s.%s %s' % (localtime, decimal, \ 
     1266                                       #time.strftime('%Z', time.localtime(timestamp))) 
     1267                 
     1268                 
     1269                #return(date, localtime) 
     1270         
     1271         
     1272        ################################################################## 
     1273         
     1274        #def saveData(self, source=None, target=None, output_file=None, use_default=False): 
     1275                 
     1276                #if source == None: 
     1277                        #if self.parent == None: 
     1278                                #source = self 
     1279                        #else: 
     1280                                #source = self.parent 
     1281                 
     1282                #if target == None: 
     1283                        #if self.parent == None: 
     1284                                #target = self 
     1285                        #else: 
     1286                                #target = self.parent 
     1287                 
     1288                #data = self.collectData(source=source, target=target) 
     1289                 
     1290                #(date, localtime) = self.parseTimeStamp(time.time()) 
     1291                 
     1292                #default_filename = '%s %s.synapse' % (date, \ 
     1293                                      #target.lineEditSessionProfile.text()) 
     1294                                       
     1295                #default_filename = os.path.join(self.homepath, default_filename) 
     1296                 
     1297                #if output_file == None: 
     1298                         
     1299                        ## use_default controls whether or not a file is automatically saves using the 
     1300                        ## default name and path (as opposed to raising a GUI file selection menu) 
     1301                        ## whenever an explicit filepath is not defined 
     1302                        #if use_default: 
     1303                                         
     1304                                        #output_file = default_filename 
     1305                         
     1306                        #else: 
     1307                         
     1308                                #output_file = QtGui.QFileDialog.getSaveFileName(parent=target, \ 
     1309                                                 #caption="Save Session Data to File", \ 
     1310                                                 #dir=default_filename, \ 
     1311                                                 #filter="Puzzlebox Synapse Data File (*.synapse)") 
     1312                                 
     1313                                #try: 
     1314                                        #output_file = output_file[0] 
     1315                                #except: 
     1316                                        #output_file = '' 
     1317                 
     1318                 
     1319                #if output_file == '': 
     1320                        #return 
     1321                 
     1322                #file = open(str(output_file), 'w') 
     1323                #pickle.dump(data, file) 
     1324                #file.close() 
     1325         
     1326         
     1327        ################################################################## 
     1328         
     1329        #def exportData(self, parent=None, source=None, target=None, output_file=None, use_default=False): 
     1330                 
     1331                #if parent == None: 
     1332                        #if self.parent == None: 
     1333                                #parent = self 
     1334                        #else: 
     1335                                #parent = self.parent 
     1336                 
     1337                #if source == None: 
     1338                        #if self.parent == None: 
     1339                                #source = self 
     1340                        #else: 
     1341                                #source = self.parent 
     1342                 
     1343                #if target == None: 
     1344                        #if self.parent == None: 
     1345                                #target = self 
     1346                        #else: 
     1347                                #target = self.parent 
     1348                 
     1349                 
     1350                #(date, localtime) = self.parseTimeStamp(time.time()) 
     1351                 
     1352                #default_filename = '%s %s.csv' % (date, \ 
     1353                                      #target.lineEditSessionProfile.text()) 
     1354                 
     1355                #default_filename = os.path.join(target.homepath, default_filename) 
     1356                 
     1357                 
     1358                #if output_file == None: 
     1359                         
     1360                        ## use_default controls whether or not a file is automatically saves using the 
     1361                        ## default name and path (as opposed to raising a GUI file selection menu) 
     1362                        ## whenever an explicit filepath is not defined 
     1363                        #if use_default: 
     1364                                         
     1365                                        #output_file = default_filename 
     1366                         
     1367                        #else: 
     1368                                #output_file = QtGui.QFileDialog.getSaveFileName(parent=target, \ 
     1369                                                 #caption="Export Session Data to File", \ 
     1370                                                 #dir=default_filename, \ 
     1371                                                 #filter="CSV File (*.csv);;Text File (*.txt)") 
     1372                                 
     1373                                #try: 
     1374                                        #output_file = output_file[0] 
     1375                                #except: 
     1376                                        #output_file = '' 
     1377                 
     1378                 
     1379                #if output_file == '': 
     1380                        #return 
     1381                 
     1382                 
     1383                #if str(output_file).endswith('.csv'): 
     1384                         
     1385                        #outputData = self.exportDataToCSV(parent=parent, source=source, target=target) 
     1386                 
     1387                 
     1388                #else: 
     1389                         
     1390                        #try: 
     1391                                #outputData = self.textEditDebugConsole.toPlainText() 
     1392                        #except: 
     1393                                #outputData = self.exportDataToCSV() 
     1394                 
     1395                 
     1396                #file = open(str(output_file), 'w') 
     1397                #file.write(outputData) 
     1398                #file.close() 
     1399         
     1400         
     1401        ################################################################## 
     1402         
     1403        #def exportDataToCSV(self, parent=None, source=None, target=None): 
     1404                 
     1405                #if parent == None: 
     1406                        #if self.parent == None: 
     1407                                #parent = self 
     1408                        #else: 
     1409                                #parent = self.parent 
     1410                 
     1411                #if source == None: 
     1412                        #if self.parent == None: 
     1413                                #source = self 
     1414                        #else: 
     1415                                #source = self.parent 
     1416                 
     1417                #if target == None: 
     1418                        #if self.parent == None: 
     1419                                #target = self 
     1420                        #else: 
     1421                                #target = self.parent 
     1422                 
     1423                #try: 
     1424                        #truncate_csv_timezone = target.configuration.EXPORT_CSV_TRUNCATE_TIMEZONE 
     1425                #except: 
     1426                        #truncate_csv_timezone = False 
     1427                 
     1428                #try: 
     1429                        #scrub_data = target.configuration.EXPORT_CSV_SCRUB_DATA 
     1430                #except: 
     1431                        #scrub_data = False 
     1432                 
     1433                 
     1434                #headers = 'Date,Time,Attention,Meditation,Signal Level,Delta,Theta,Low Alpha,High Alpha,Low Beta,High Beta,Low Gamma,Mid Gamma' 
     1435                 
     1436                #customDataHeaders = [] 
     1437                #for header in parent.customDataHeaders: 
     1438                        #customDataHeaders.append(header) 
     1439                #for plugin in parent.activePlugins: 
     1440                        #for header in plugin.customDataHeaders: 
     1441                                #customDataHeaders.append(header) 
     1442                 
     1443                #for each in customDataHeaders: 
     1444                        #headers = headers + ',%s' % each 
     1445                 
     1446                #headers = headers + '\n' 
     1447                 
     1448                #csv = {} 
     1449                 
     1450                #for packet in source.packets['signals']: 
     1451                         
     1452                         
     1453                        #if 'rawEeg' in packet.keys(): 
     1454                                #continue 
     1455                         
     1456                        #if packet['timestamp'] not in csv.keys(): 
     1457                                 
     1458                                #if 'blinkStrength' in packet.keys(): 
     1459                                        ## Skip any blink packets from log 
     1460                                        #continue 
     1461                                 
     1462                                 
     1463                                ##print packet 
     1464                                #timestamp = packet['timestamp'] 
     1465                                #(date, localtime) = self.parseTimeStamp(timestamp, \ 
     1466                                                    #truncate_time_zone=truncate_csv_timezone) 
     1467                                 
     1468                                #csv[timestamp] = {} 
     1469                                #csv[timestamp]['Date'] = date 
     1470                                #csv[timestamp]['Time'] = localtime 
     1471                                #csv[timestamp]['Attention'] = '' 
     1472                                #csv[timestamp]['Meditation'] = '' 
     1473                                #csv[timestamp]['Signal Level'] = '' 
     1474                                #csv[timestamp]['Delta'] = '' 
     1475                                #csv[timestamp]['Theta'] = '' 
     1476                                #csv[timestamp]['Low Alpha'] = '' 
     1477                                #csv[timestamp]['High Alpha'] = '' 
     1478                                #csv[timestamp]['Low Beta'] = '' 
     1479                                #csv[timestamp]['High Beta'] = '' 
     1480                                #csv[timestamp]['Low Gamma'] = '' 
     1481                                #csv[timestamp]['Mid Gamma'] = '' 
     1482                                 
     1483                                #for header in customDataHeaders: 
     1484                                        #csv[timestamp][header] = '' 
     1485                         
     1486                         
     1487                        #if 'eSense' in packet.keys(): 
     1488                                #if 'attention' in packet['eSense'].keys(): 
     1489                                        #csv[timestamp]['Attention'] = packet['eSense']['attention'] 
     1490                                #if 'meditation' in packet['eSense'].keys(): 
     1491                                        #csv[timestamp]['Meditation'] = packet['eSense']['meditation'] 
     1492                         
     1493                        #if 'eegPower' in packet.keys(): 
     1494                                #if 'delta' in packet['eegPower'].keys(): 
     1495                                        #csv[timestamp]['Delta'] = packet['eegPower']['delta'] 
     1496                                #if 'theta' in packet['eegPower'].keys(): 
     1497                                        #csv[timestamp]['Theta'] = packet['eegPower']['theta'] 
     1498                                #if 'lowAlpha' in packet['eegPower'].keys(): 
     1499                                        #csv[timestamp]['Low Alpha'] = packet['eegPower']['lowAlpha'] 
     1500                                #if 'highAlpha' in packet['eegPower'].keys(): 
     1501                                        #csv[timestamp]['High Alpha'] = packet['eegPower']['highAlpha'] 
     1502                                #if 'lowBeta' in packet['eegPower'].keys(): 
     1503                                        #csv[timestamp]['Low Beta'] = packet['eegPower']['lowBeta'] 
     1504                                #if 'highBeta' in packet['eegPower'].keys(): 
     1505                                        #csv[timestamp]['High Beta'] = packet['eegPower']['highBeta'] 
     1506                                #if 'lowGamma' in packet['eegPower'].keys(): 
     1507                                        #csv[timestamp]['Low Gamma'] = packet['eegPower']['lowGamma'] 
     1508                                #if 'highGamma' in packet['eegPower'].keys(): 
     1509                                        #csv[timestamp]['Mid Gamma'] = packet['eegPower']['highGamma'] 
     1510                         
     1511                        #if 'poorSignalLevel' in packet.keys(): 
     1512                                #csv[timestamp]['Signal Level'] = packet['poorSignalLevel'] 
     1513                         
     1514                        #for header in customDataHeaders: 
     1515                                #if 'custom' in packet.keys() and \ 
     1516                                   #header in packet['custom'].keys(): 
     1517                                        #csv[timestamp][header] = packet['custom'][header] 
     1518                 
     1519                 
     1520                #if scrub_data: 
     1521                        #csv = self.scrubData(csv, truncate_csv_timezone) 
     1522                 
     1523                 
     1524                #output = headers 
     1525                 
     1526                #csv_keys = csv.keys() 
     1527                #csv_keys.sort() 
     1528                 
     1529                #for key in csv_keys: 
     1530                         
     1531                        #row = '%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s' % \ 
     1532                              #(csv[key]['Date'], \ 
     1533                               #csv[key]['Time'], \ 
     1534                               #csv[key]['Attention'], \ 
     1535                               #csv[key]['Meditation'], \ 
     1536                               #csv[key]['Signal Level'], \ 
     1537                               #csv[key]['Delta'], \ 
     1538                               #csv[key]['Theta'], \ 
     1539                               #csv[key]['Low Alpha'], \ 
     1540                               #csv[key]['High Alpha'], \ 
     1541                               #csv[key]['Low Beta'], \ 
     1542                               #csv[key]['High Beta'], \ 
     1543                               #csv[key]['Low Gamma'], \ 
     1544                               #csv[key]['Mid Gamma']) 
     1545                         
     1546                        #for header in customDataHeaders: 
     1547                                #row = row + ',%s' % csv[key][header] 
     1548                         
     1549                        #row = row + '\n' 
     1550                         
     1551                        #output = output + row 
     1552                 
     1553                 
     1554                #return(output) 
     1555         
     1556         
     1557        ################################################################## 
     1558         
     1559        #def scrubData(self, csv, truncate_csv_timezone=False): 
     1560                 
     1561                ## If there are missing packets, repeat a given packet once per missing 
     1562                ## second until there is a gap between 1 and 2 seconds, in which case 
     1563                ## produce a final duplicate packet at the mid-point between the packets 
     1564 
     1565                #if self.DEBUG: 
     1566                        #print "INFO: Scrubbing Data" 
     1567                 
     1568                #last_time = None 
     1569                #last_recorded_time = None 
     1570                 
     1571                #output = {} 
     1572                 
     1573                #csv_keys = csv.keys() 
     1574                #csv_keys.sort() 
     1575                 
     1576                #for key in csv_keys: 
     1577                         
     1578                        #timestamp = key 
     1579 
     1580                        #if csv[key]['Attention'] == '': 
     1581                                #continue 
     1582                         
     1583                        #if last_time == None: 
     1584                                ## First entry in log 
     1585                                #last_time = timestamp 
     1586                                #last_recorded_time = timestamp 
     1587                                #output[key] = csv[key] 
     1588                                #continue 
     1589                         
     1590                        #else: 
     1591                                 
     1592                                ##time_difference = timestamp - last_time 
     1593                                #time_difference = timestamp - last_recorded_time 
     1594                                 
     1595                                #if (time_difference <= 1) and \ 
     1596                                   #(time_difference >= PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD): 
     1597                                        ## Skip packets within the correct time threshold 
     1598                                        #last_time = timestamp 
     1599                                        #last_recorded_time = timestamp 
     1600                                        #output[key] = csv[key] 
     1601                                        #continue 
     1602                                 
     1603                                #else: 
     1604                                         
     1605                                        #if self.DEBUG > 1: 
     1606                                                #print "time_difference:", 
     1607                                                #print time_difference 
     1608                                                #print "timestamp:", 
     1609                                                #print self.parseTimeStamp(timestamp)[-1].split(' ')[0] 
     1610                                                #print "last_time:", 
     1611                                                #print self.parseTimeStamp(last_time)[-1].split(' ')[0] 
     1612                                                #print "last_recorded_time:", 
     1613                                                #print self.parseTimeStamp(last_recorded_time)[-1].split(' ')[0] 
     1614                                         
     1615                                         
     1616                                        #new_packet = csv[key].copy() 
     1617                                         
     1618                                        #if time_difference >= 2: 
     1619                                                 
     1620                                                ###new_time = last_time + 1 
     1621                                                ##new_time = last_recorded_time + 1 
     1622                                                 
     1623                                                #count = int(time_difference) 
     1624                                                #while count >= 1: 
     1625                                                        #new_packet = csv[key].copy() 
     1626                                                        #new_time = last_recorded_time + 1 
     1627                                                        #(date, formatted_new_time) = self.parseTimeStamp(new_time, \ 
     1628                                                         #truncate_time_zone=truncate_csv_timezone) 
     1629                                                        #new_packet['Time'] = formatted_new_time 
     1630                                                        #last_recorded_time = new_time 
     1631                                                        #last_time = timestamp 
     1632                                                        #output[new_time] = new_packet 
     1633                                                        #count = count - 1 
     1634                                                #continue 
     1635                                                 
     1636                                        #elif time_difference < PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD: 
     1637                                                ## Spread out "bunched up" packets 
     1638                                                ##new_time = last_time + 1 
     1639                                                #new_time = last_recorded_time + 1 
     1640                                         
     1641                                         
     1642                                        #elif (time_difference < 2) and (time_difference > 1): 
     1643                                                 
     1644                                                ##new_time = last_time + ((last_time - timestamp) / 2) 
     1645                                                ##new_time = last_recorded_time + ((last_recorded_time - timestamp) / 2) 
     1646                                                ##new_time = last_time + 1 
     1647                                                #new_time = last_recorded_time + 1 
     1648                                         
     1649                                         
     1650                                        #(date, formatted_new_time) = self.parseTimeStamp(new_time, \ 
     1651                                           #truncate_time_zone=truncate_csv_timezone) 
     1652                                         
     1653                                        #new_packet['Time'] = formatted_new_time 
     1654                                         
     1655                                        ##last_time = new_time 
     1656                                        #last_recorded_time = new_time 
     1657                                        #last_time = timestamp 
     1658                                        #output[new_time] = new_packet 
     1659                                         
     1660                                        #if self.DEBUG > 1: 
     1661                                                #print "WARN: Scrubbing new packet:", 
     1662                                                #print new_packet 
     1663                                                #print 
     1664                 
     1665                 
     1666                #return(output) 
     1667         
     1668         
     1669        ################################################################## 
     1670         
     1671        #def resetData(self, source=None): 
     1672                 
     1673                #if source == None: 
     1674                        #if self.parent == None: 
     1675                                #source = self 
     1676                        #else: 
     1677                                #source = self.parent 
     1678                 
     1679                ##if target == None: 
     1680                        ##if self.parent == None: 
     1681                                ##target = self 
     1682                        ##else: 
     1683                                ##target = self.parent 
     1684                 
     1685                #source.packets['rawEeg'] = [] 
     1686                #source.packets['signals'] = [] 
     1687                 
     1688                #source.synapseServer.protocol.session_start_timestamp = \ 
     1689                        #time.time() 
     1690                 
     1691                #source.synapseServer.protocol.packet_count = 0 
     1692                #source.synapseServer.protocol.bad_packets = 0 
     1693                 
     1694                #self.updateProfileSessionStatus() 
     1695                 
     1696                #try: 
     1697                        #source.textEditDebugConsole.setText("") 
     1698                #except: 
     1699                        #pass 
    17571700         
    17581701         
    17591702        ##################################################################### 
    17601703         
    1761         def convert_seconds_to_datetime(self, duration): 
    1762                  
    1763                 duration_hours = duration / (60 * 60) 
    1764                 duration_minutes = (duration - (duration_hours * (60 * 60))) / 60 
    1765                 duration_seconds = (duration - (duration_hours * (60 * 60)) - (duration_minutes * 60)) 
    1766                  
    1767                 duration_hours = '%i' % duration_hours 
    1768                 if (len(duration_hours) == 1): 
    1769                         duration_hours = "0%s" % duration_hours 
    1770                  
    1771                 duration_minutes = '%i' % duration_minutes 
    1772                 if (len(duration_minutes) == 1): 
    1773                         duration_minutes = "0%s" % duration_minutes 
    1774                  
    1775                 duration_seconds = '%i' % duration_seconds 
    1776                 if (len(duration_seconds) == 1): 
    1777                         duration_seconds = "0%s" % duration_seconds 
    1778                  
    1779                 datetime = '%s:%s:%s' % (duration_hours, duration_minutes, duration_seconds) 
    1780                  
    1781                 return(datetime) 
     1704        #def convert_seconds_to_datetime(self, duration): 
     1705                 
     1706                #duration_hours = duration / (60 * 60) 
     1707                #duration_minutes = (duration - (duration_hours * (60 * 60))) / 60 
     1708                #duration_seconds = (duration - (duration_hours * (60 * 60)) - (duration_minutes * 60)) 
     1709                 
     1710                #duration_hours = '%i' % duration_hours 
     1711                #if (len(duration_hours) == 1): 
     1712                        #duration_hours = "0%s" % duration_hours 
     1713                 
     1714                #duration_minutes = '%i' % duration_minutes 
     1715                #if (len(duration_minutes) == 1): 
     1716                        #duration_minutes = "0%s" % duration_minutes 
     1717                 
     1718                #duration_seconds = '%i' % duration_seconds 
     1719                #if (len(duration_seconds) == 1): 
     1720                        #duration_seconds = "0%s" % duration_seconds 
     1721                 
     1722                #datetime = '%s:%s:%s' % (duration_hours, duration_minutes, duration_seconds) 
     1723                 
     1724                #return(datetime) 
    17821725         
    17831726         
  • trunk/Puzzlebox/Synapse/Server.py

    r365 r370  
    107107        ################################################################## 
    108108         
    109         #def configureEEG(self): 
    110                  
    111                 #if (self.device_model == 'NeuroSky MindWave' or \ 
    112                     #self.device_model == 'NeuroSky MindSet'): 
    113                          
    114                         #self.thinkgearServer = \ 
    115                                 #thinkgear_server.puzzlebox_synapse_server_thinkgear( \ 
    116                                         #self.log, \ 
    117                                         #device_model=self.device_model, \ 
    118                                         #device_address=self.device_address, \ 
    119                                         #emulate_headset_data=self.emulate_headset_data, \ 
    120                                         #DEBUG=DEBUG, \ 
    121                                         #parent=self) 
    122                          
    123                         #self.connect(self.thinkgearServer, \ 
    124                                      #QtCore.SIGNAL("sendPacket()"), \ 
    125                                      #self.sendPacketQueue) 
    126                          
    127                         #self.thinkgearServer.start() 
    128                          
    129                         #self.protocolServers.append(self.thinkgearServer) 
    130          
    131          
    132         ################################################################## 
    133          
    134109        def configureNetwork(self): 
    135110         
     
    356331        ################################################################## 
    357332         
    358         #def processPacketEmotiv(self, packet): 
    359                  
    360                 #if self.DEBUG > 2: 
    361                         #print packet 
    362                  
    363                 #if (packet != {}): 
    364                         #self.packet_queue.append(packet) 
    365                          
    366                         #if COMMUNICATION_MODE == 'Emit Signal': 
    367                                 #self.emitSendPacketSignal() 
    368                          
    369                         #else: 
    370                                 #self.sendPacketQueue() 
    371                                  
    372                                 #if (self.parent != None): 
    373                                         #self.parent.processPacketEmotiv(packet) 
    374          
    375          
    376         ################################################################## 
    377          
    378333        def updateSessionStartTime(self, session_start_timestamp): 
    379334                 
Note: See TracChangeset for help on using the changeset viewer.