Changeset 364 for trunk


Ignore:
Timestamp:
03/30/12 23:16:22 (8 years ago)
Author:
sc
Message:
  • Refactor ThinkGear?.Server to inherit Synapse.Server
Location:
trunk/Puzzlebox/Synapse
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/Puzzlebox/Synapse/Emotiv/Client.py

    r363 r364  
    2828        from PyQt4 import QtCore, QtGui, QtNetwork 
    2929 
    30 import Protocol as emotiv_protocol 
     30try: 
     31        import Protocol as emotiv_protocol 
     32except Exception, e: 
     33        print "ERROR: [Synapse:Emotiv:Client] Exception importing Emotiv.Protocol:", 
     34        print e 
     35        emotiv_protocol = None 
    3136 
    3237##################################################################### 
     
    8893        def configureNetwork(self): 
    8994                 
    90                 emotiv_protocol.start(host=self.server_host, \ 
    91                                       port=self.server_port, \ 
    92                                       initialized=False, \ 
    93                                       parent=self) 
     95                if emotiv_protocol != None: 
     96                 
     97                        emotiv_protocol.start(host=self.server_host, \ 
     98                                              port=self.server_port, \ 
     99                                              initialized=False, \ 
     100                                              parent=self) 
    94101         
    95102         
     
    119126        def stop(self): 
    120127                 
    121                 #try: 
    122                         #self.disconnectFromHost() 
    123                 #except: 
    124                         #pass 
    125                  
    126                 emotiv_protocol.KEEP_RUNNING = False 
    127                  
    128                 count = 1 
    129                 while emotiv_protocol.CONNECTED: 
    130                         time.sleep(0.10) 
    131                         count = count + 1 
    132                         if count >= 10: 
    133                                 break 
     128                if emotiv_protocol != None: 
     129                        emotiv_protocol.KEEP_RUNNING = False 
     130                         
     131                        count = 1 
     132                        while emotiv_protocol.CONNECTED: 
     133                                time.sleep(0.10) 
     134                                count = count + 1 
     135                                if count >= 10: 
     136                                        break 
    134137         
    135138         
  • trunk/Puzzlebox/Synapse/Interface.py

    r363 r364  
    6464from Interface_Design import Ui_Form as Design 
    6565 
    66 import Puzzlebox.Synapse.Server as synapse_server 
     66#import Puzzlebox.Synapse.Server as synapse_server 
     67import Puzzlebox.Synapse.ThinkGear.Server as thinkgear_server 
    6768import Puzzlebox.Synapse.ThinkGear.Client as thinkgear_client 
     69#import Puzzlebox.Synapse.Emotiv.Server as emotiv_server 
    6870import Puzzlebox.Synapse.Emotiv.Client as emotiv_client 
    6971#import puzzlebox_logger 
     
    291293                eeg_headset_model = str(self.comboBoxEEGHeadsetModel.currentText()) 
    292294                device_address = str(self.comboBoxDeviceSelect.currentText()) 
    293                 server_interface = str(self.lineEditSynapseHost.text()) 
    294                 server_port = int(self.lineEditSynapsePort.text()) 
    295                 emulate_headset_data = (device_address == 'ThinkGear Emulator') 
     295                #server_interface = str(self.lineEditSynapseHost.text()) 
     296                #server_port = int(self.lineEditSynapsePort.text()) 
     297                #emulate_headset_data = (device_address == 'ThinkGear Emulator') 
    296298                 
    297299                 
     
    300302                 
    301303                 
    302                 self.synapseServer = \ 
    303                         synapse_server.puzzlebox_synapse_server( \ 
    304                                 self.log, \ 
    305                                 server_interface=server_interface, \ 
    306                                 server_port=server_port, \ 
    307                                 device_model=eeg_headset_model, \ 
    308                                 device_address=device_address, \ 
    309                                 emulate_headset_data=emulate_headset_data, \ 
    310                                 DEBUG=DEBUG, \ 
    311                                 parent=self) 
    312                  
    313                 self.synapseServer.start() 
     304                #self.synapseServer = \ 
     305                        #synapse_server.puzzlebox_synapse_server( \ 
     306                                #self.log, \ 
     307                                #server_interface=server_interface, \ 
     308                                #server_port=server_port, \ 
     309                                #device_model=eeg_headset_model, \ 
     310                                #device_address=device_address, \ 
     311                                #emulate_headset_data=emulate_headset_data, \ 
     312                                #DEBUG=DEBUG, \ 
     313                                #parent=self) 
     314                 
     315                #self.synapseServer.start() 
    314316                 
    315317                 
     
    317319                    (eeg_headset_model == 'NeuroSky MindSet')): 
    318320                         
    319                         self.startThinkGearConnectClient() 
     321                        self.startThinkGearConnectService() 
    320322                 
    321323                elif (eeg_headset_model == 'Emotiv EPOC'): 
    322324                         
    323                         self.startEmotivClient() 
     325                        self.startEmotivService() 
    324326                 
    325327                 
     
    361363        def stopSynapseServer(self): 
    362364                 
    363                  
    364365                eeg_headset_model = str(self.comboBoxEEGHeadsetModel.currentText()) 
    365366                device_address = str(self.comboBoxDeviceSelect.currentText()) 
     
    368369                    (eeg_headset_model == 'NeuroSky MindSet')): 
    369370                         
    370                         self.stopThinkGearConnectClient() 
     371                        self.stopThinkGearConnectService() 
    371372                 
    372373                elif (eeg_headset_model == 'Emotiv EPOC'): 
    373374                         
    374                         self.stopEmotivClient() 
     375                        self.stopEmotivService() 
    375376                 
    376377                 
     
    442443        ################################################################## 
    443444         
    444         def startThinkGearConnectClient(self): 
     445        def startThinkGearConnectService(self): 
    445446                 
    446447                server_interface = str(self.lineEditSynapseHost.text()) 
    447448                server_port = int(self.lineEditSynapsePort.text()) 
     449                eeg_headset_model = str(self.comboBoxEEGHeadsetModel.currentText()) 
     450                device_address = str(self.comboBoxDeviceSelect.currentText()) 
     451                emulate_headset_data = (device_address == 'ThinkGear Emulator') 
     452                 
     453                 
     454                self.synapseServer = \ 
     455                        thinkgear_server.puzzlebox_synapse_server_thinkgear( \ 
     456                                self.log, \ 
     457                                server_interface=server_interface, \ 
     458                                server_port=server_port, \ 
     459                                device_model=eeg_headset_model, \ 
     460                                device_address=device_address, \ 
     461                                emulate_headset_data=emulate_headset_data, \ 
     462                                DEBUG=DEBUG, \ 
     463                                parent=self) 
     464                 
     465                self.synapseServer.start() 
     466                 
    448467                 
    449468                if UPDATE_INTERFACE_VIA_TIMER: 
     
    464483        ################################################################## 
    465484         
    466         def stopThinkGearConnectClient(self): 
     485        def stopThinkGearConnectService(self): 
    467486                 
    468487                if UPDATE_INTERFACE_VIA_TIMER: 
     
    470489                else: 
    471490                        try: 
    472                                 self.thinkgearConnectClient.disconnectFromHost() 
     491                                self.thinkgearConnectClient.exitThread() 
     492                                #self.thinkgearConnectClient.disconnectFromHost() 
    473493                        except Exception, e: 
    474494                                if self.DEBUG: 
    475                                         print "Call failed to self.thinkgearConnectClient.disconnectFromHost():", 
     495                                        print "Call failed to self.thinkgearConnectClient.exitThread():", 
     496                                        #print "Call failed to self.thinkgearConnectClient.disconnectFromHost():", 
    476497                                        print e 
    477498         
     
    479500        ################################################################## 
    480501         
    481         def startEmotivClient(self): 
     502        def startEmotivService(self): 
    482503                 
    483504                eeg_headset_model = str(self.comboBoxEEGHeadsetModel.currentText()) 
     
    517538        ################################################################## 
    518539         
    519         def stopEmotivClient(self): 
     540        def stopEmotivService(self): 
    520541                 
    521542                self.emotivClient.stop() 
  • trunk/Puzzlebox/Synapse/Server.py

    r363 r364  
    3333        from PyQt4 import QtCore, QtGui, QtNetwork 
    3434 
    35 import Puzzlebox.Synapse.ThinkGear.Server as thinkgear_server 
     35#import Puzzlebox.Synapse.ThinkGear.Server as thinkgear_server 
    3636 
    3737 
     
    4949DEFAULT_DEVICE_MODEL = 'NeuroSky MindWave' 
    5050THINKGEAR_DEVICE_SERIAL_PORT = configuration.THINKGEAR_DEVICE_SERIAL_PORT 
    51 #THINKGEAR_DEVICE_ID = configuration.THINKGEAR_DEVICE_ID 
    5251 
    5352CLIENT_NO_REPLY_WAIT = configuration.CLIENT_NO_REPLY_WAIT * 1000 
     
    102101                             self.sendPacketQueue) 
    103102                 
    104                 self.protocolServers = [] 
    105                  
    106                 self.configureEEG() 
     103                #self.protocolServers = [] 
     104                 
     105                #self.configureEEG() 
    107106                 
    108107                self.configureNetwork() 
     
    111110        ################################################################## 
    112111         
    113         def configureEEG(self): 
    114                  
    115                 if (self.device_model == 'NeuroSky MindWave' or \ 
    116                     self.device_model == 'NeuroSky MindSet'): 
    117                          
    118                         self.thinkgearServer = \ 
    119                                 thinkgear_server.puzzlebox_synapse_server_thinkgear( \ 
    120                                         self.log, \ 
    121                                         device_model=self.device_model, \ 
    122                                         device_address=self.device_address, \ 
    123                                         emulate_headset_data=self.emulate_headset_data, \ 
    124                                         DEBUG=DEBUG, \ 
    125                                         parent=self) 
    126                          
    127                         self.connect(self.thinkgearServer, \ 
    128                                      QtCore.SIGNAL("sendPacket()"), \ 
    129                                      self.sendPacketQueue) 
    130                          
    131                         self.thinkgearServer.start() 
    132                          
    133                         self.protocolServers.append(self.thinkgearServer) 
     112        #def configureEEG(self): 
     113                 
     114                #if (self.device_model == 'NeuroSky MindWave' or \ 
     115                    #self.device_model == 'NeuroSky MindSet'): 
     116                         
     117                        #self.thinkgearServer = \ 
     118                                #thinkgear_server.puzzlebox_synapse_server_thinkgear( \ 
     119                                        #self.log, \ 
     120                                        #device_model=self.device_model, \ 
     121                                        #device_address=self.device_address, \ 
     122                                        #emulate_headset_data=self.emulate_headset_data, \ 
     123                                        #DEBUG=DEBUG, \ 
     124                                        #parent=self) 
     125                         
     126                        #self.connect(self.thinkgearServer, \ 
     127                                     #QtCore.SIGNAL("sendPacket()"), \ 
     128                                     #self.sendPacketQueue) 
     129                         
     130                        #self.thinkgearServer.start() 
     131                         
     132                        #self.protocolServers.append(self.thinkgearServer) 
    134133         
    135134         
     
    346345                 
    347346                 
    348                 else: 
    349                          
    350                         for server in self.protocolServers: 
    351                                  
    352                                 # Accept the first valid response received 
    353                                 if response == None: 
    354                                         response = server.processData(data) 
     347                #else: 
     348                         
     349                        #for server in self.protocolServers: 
     350                                 
     351                                ## Accept the first valid response received 
     352                                #if response == None: 
     353                                        #response = server.processData(data) 
    355354                 
    356355                 
  • trunk/Puzzlebox/Synapse/ThinkGear/Protocol.py

    r363 r364  
    162162        def __init__(self, log, \ 
    163163                               serial_device, \ 
    164                                #device_id=None, \ 
    165164                               device_model=None, \ 
    166165                               DEBUG=DEBUG, \ 
     
    542541                                #self.session_start_timestamp = time.time() 
    543542                                self.resetSessionStartTime() 
     543                                #print "okay" 
    544544                                self.packet_count = 0 
    545545                                self.bad_packets = 0 
     
    881881                                if self.device_model != None and self.DEBUG: 
    882882                                        print "INFO: %s device model selected" % self.device_model 
     883                         
    883884                        self.parseStream() 
    884885         
     
    887888         
    888889        def exitThread(self, callThreadQuit=True): 
    889                  
    890                 #if self.device != None and self.device.device != None: 
    891                         #if self.device_model == 'NeuroSky MindWave': 
    892                                 #if self.DEBUG: 
    893                                         #print "INFO: ThinkGear device model MindWave selected. Writing disconnect packet." 
    894                                 #try: 
    895                                         #self.device.device.write('\xc1') 
    896                                 #except Exception, e: 
    897                                         #if self.DEBUG: 
    898                                                 #print "ERROR: failed to write disconnect packet: ", 
    899                                                 #print e 
    900890                 
    901891                self.disconnectHardware() 
  • trunk/Puzzlebox/Synapse/ThinkGear/Server.py

    r363 r364  
    3535        from PyQt4 import QtCore, QtGui, QtNetwork 
    3636 
    37  
     37import Puzzlebox.Synapse.Server as synapse_server 
    3838import Puzzlebox.Synapse.ThinkGear.Protocol as thinkgear_protocol 
    3939 
     
    4747#COMMUNICATION_MODE = 'Call Parent' 
    4848 
     49SERVER_INTERFACE = configuration.THINKGEAR_SERVER_INTERFACE 
     50SERVER_PORT = configuration.THINKGEAR_SERVER_PORT 
     51DEFAULT_DEVICE_MODEL = 'NeuroSky MindWave' 
    4952THINKGEAR_DEVICE_SERIAL_PORT = configuration.THINKGEAR_DEVICE_SERIAL_PORT 
    50 #THINKGEAR_DEVICE_ID = configuration.THINKGEAR_DEVICE_ID 
    5153 
    5254CLIENT_NO_REPLY_WAIT = configuration.CLIENT_NO_REPLY_WAIT * 1000 
     
    132134##################################################################### 
    133135 
    134 class puzzlebox_synapse_server_thinkgear(QtCore.QThread): 
     136#class puzzlebox_synapse_server_thinkgear(QtCore.QThread): 
     137class puzzlebox_synapse_server_thinkgear(synapse_server.puzzlebox_synapse_server): 
    135138         
    136139        def __init__(self, log, \ 
     140                          server_interface=SERVER_INTERFACE, \ 
     141                          server_port=SERVER_PORT, \ 
     142                          device_model=None, \ 
    137143                          device_address=THINKGEAR_DEVICE_SERIAL_PORT, \ 
    138                           #device_id=THINKGEAR_DEVICE_ID, \ 
    139                           device_model=None, \ 
    140144                          emulate_headset_data=ENABLE_SIMULATE_HEADSET_DATA, \ 
    141145                          DEBUG=DEBUG, \ 
     
    148152                self.parent = parent 
    149153                 
     154                self.server_interface = server_interface 
     155                self.server_port = server_port 
    150156                self.device_address = device_address 
    151                 #self.device_id = device_id 
    152157                self.device_model = device_model 
    153158                self.emulate_headset_data = emulate_headset_data 
     
    155160                self.name = 'Synapse:ThinkGear:Server' 
    156161                 
    157                 self.message_frequency_timer = MESSAGE_FREQUENCY_TIMER 
    158                 self.blink_frequency_timer = BLINK_FREQUENCY_TIMER 
    159                  
    160162                self.connection_timestamp = time.time() 
    161                 self.blink_timestamp = time.time() 
     163                self.session_start_timestamp = time.time() 
    162164                 
    163165                self.connections = [] 
     
    171173                             self.sendPacketQueue) 
    172174                 
     175                self.message_frequency_timer = MESSAGE_FREQUENCY_TIMER 
     176                self.blink_frequency_timer = BLINK_FREQUENCY_TIMER 
     177                self.blink_timestamp = time.time() 
     178                 
     179                 
    173180                self.configureEEG() 
     181                 
     182                self.configureNetwork() 
     183                 
    174184                 
    175185                if (self.emulate_headset_data): 
     
    204214                                self.log, \ 
    205215                                self.serial_device, \ 
    206                                 #device_id=self.device_id, \ 
    207216                                device_model=self.device_model, \ 
    208217                                DEBUG=self.DEBUG, \ 
     
    226235        ################################################################## 
    227236         
    228         def emitSendPacketSignal(self): 
    229                  
    230                 self.emit(QtCore.SIGNAL("sendPacket()")) 
    231          
    232          
    233         ################################################################## 
    234          
    235         def sendPacketQueue(self): 
    236                  
    237                 if (self.parent != None): 
    238                          
    239                         for packet in self.packet_queue: 
    240                                 self.parent.packet_queue.append(packet) 
    241                          
    242                         #self.parent.sendPacketQueue() 
     237        #def emitSendPacketSignal(self): 
     238                 
     239                #self.emit(QtCore.SIGNAL("sendPacket()")) 
     240         
     241         
     242        ################################################################## 
     243         
     244        #def sendPacketQueue(self): 
     245                 
     246                #if (self.parent != None): 
     247                         
     248                        #for packet in self.packet_queue: 
     249                                #self.parent.packet_queue.append(packet) 
     250                         
     251                        ##self.parent.sendPacketQueue() 
    243252         
    244253         
     
    257266                 
    258267                 
    259                 if (type(data) == type({}) and \ 
     268                elif (type(data) == type({}) and \ 
    260269                      data.has_key('appName') and \ 
    261270                      data.has_key('appKey')): 
     271                         
    262272                        authorized = self.authorizeClient(data) 
    263273                         
     
    451461        ################################################################## 
    452462         
    453         def updateSessionStartTime(self, session_start_timestamp): 
    454                  
    455                 if self.parent != None: 
    456                         self.parent.updateSessionStartTime(session_start_timestamp) 
    457          
    458          
    459         ################################################################## 
    460          
    461         def run(self): 
    462                  
    463                 if self.DEBUG: 
    464                         print "<---- [%s] Main thread running" % self.name 
    465                  
    466                 self.exec_() 
    467          
    468                  
     463        #def updateSessionStartTime(self, session_start_timestamp): 
     464                 
     465                #if self.parent != None: 
     466                        #self.parent.updateSessionStartTime(session_start_timestamp) 
     467 
     468         
     469        ################################################################## 
     470         
     471        def resetDevice(self): 
     472                 
     473                if self.serial_device != None: 
     474                        self.serial_device.exitThread() 
     475                 
     476                if self.protocol != None: 
     477                        self.protocol.exitThread() 
     478                 
     479                self.configureEEG() 
     480         
     481         
     482        ################################################################## 
     483         
     484        #def run(self): 
     485                 
     486                #if self.DEBUG: 
     487                        #print "<---- [%s] Main thread running" % self.name 
     488                 
     489                #self.exec_() 
     490         
     491         
    469492        ################################################################## 
    470493         
     
    496519                        self.protocol.exitThread() 
    497520                 
    498                 #self.socket.close() 
     521                self.socket.close() 
    499522                 
    500523                if callThreadQuit: 
     
    507530        ################################################################## 
    508531         
    509         def resetDevice(self): 
    510                  
    511                 if self.serial_device != None: 
    512                         self.serial_device.exitThread() 
    513                  
    514                 if self.protocol != None: 
    515                         self.protocol.exitThread() 
    516                  
    517                 self.configureEEG() 
    518  
     532        #def stop(self): 
     533                 
     534                #self.exitThread() 
     535 
  • trunk/Puzzlebox/Synapse/__init__.py

    r163 r364  
    11# -*- coding: utf-8 -*- 
    22__doc__ = """\ 
    3 Copyright Puzzlebox Productions, LLC (2010) 
     3Copyright Puzzlebox Productions, LLC (2010-2012) 
    44This code is released under the GNU Pulic License (GPL) version 2 
    55For more information please refer to http://www.gnu.org/copyleft/gpl.html 
    6  
    7  
    86""" 
Note: See TracChangeset for help on using the changeset viewer.