Changeset 152


Ignore:
Timestamp:
08/09/10 16:07:24 (11 years ago)
Author:
sc
Message:

synapse/puzzlebox_synapse_client_thinkgear.py:

  • updated for PySide? QHostAddress handling

synapse/puzzlebox_synapse_protocol_thinkgear.py:

  • packet processing handed off to parent

synapse/puzzlebox_synapse_interface.py:

  • updateInterface added
  • interface updated via timer instead of child processes
  • support for ThinkGear? Connect client processing (commented out by default)

synapse/puzzlebox_synapse_server_thinkgear.py:

  • Emulation timer only called in emulation mode
  • processPacketThinkGear added
  • updateStatus cleanup
Location:
synapse
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • synapse/puzzlebox_synapse_client_thinkgear.py

    r151 r152  
    8484                self.socket.name = 'ThinkGear Client' 
    8585                 
     86                if ((self.server_host == '') or \ 
     87                         (self.server_host == '*')): 
     88                        self.server_host=QtNetwork.QHostAddress.Any 
     89                 
    8690                self.socket.readyRead.connect(self.printReply) 
    8791                self.socket.error.connect(self.displayError) 
  • synapse/puzzlebox_synapse_interface.py

    r151 r152  
    3737#from PySide import QtCore, QtGui 
    3838 
    39 from PyQt4 import QtNetwork 
     39#from PyQt4 import QtNetwork 
    4040 
    4141from puzzlebox_synapse_interface_design import Ui_Form 
     
    7272PATH_TO_HCITOOL = '/usr/bin/hcitool' 
    7373 
    74 DEBUG_CONSOLE_UPDATE_FREQUENCY = 100 # ms 
     74INTERFACE_UPDATE_FREQUENCY = 1000 # ms 
    7575 
    7676##################################################################### 
     
    100100                self.debug_console_buffer = '' 
    101101                 
    102                 self.updateDebugConsoleTimer = QtCore.QTimer() 
    103                 QtCore.QObject.connect(self.updateDebugConsoleTimer, \ 
     102                self.updateInterfaceTimer = QtCore.QTimer() 
     103                QtCore.QObject.connect(self.updateInterfaceTimer, \ 
    104104                                            QtCore.SIGNAL("timeout()"), \ 
    105                                             self.writeDebugConsoleBuffer) 
    106                 self.updateDebugConsoleTimer.start(DEBUG_CONSOLE_UPDATE_FREQUENCY) 
     105                                            self.updateInterface) 
    107106         
    108107         
     
    122121                # ThinkGear Device 
    123122                 
    124                 #print self.comboBoxDeviceSelect.currentText() 
     123                self.searchForThinkGearDevices() 
    125124                 
    126125                 
     
    294293                        self.thinkGearConnectServer.start() 
    295294                         
     295                        self.updateInterfaceTimer.start(INTERFACE_UPDATE_FREQUENCY) 
    296296                         
    297297                        #self.thinkgearConnectClient = \ 
     
    326326                #self.thinkgearConnectClient.disconnectFromHost() 
    327327                 
     328                self.updateInterfaceTimer.stop() 
     329                 
    328330                self.thinkGearConnectServer.exitThread() 
    329331                 
     
    347349        ################################################################## 
    348350         
    349         def updateDebugConsole(self, output): 
    350                  
    351                 self.debug_console_buffer += output 
    352          
    353          
    354         ################################################################## 
    355          
    356         def writeDebugConsoleBuffer(self): 
    357                  
    358                 '''We call this in a separate method in order to remain threadsafe''' 
    359                  
    360                 output = self.debug_console_buffer 
    361                 self.debug_console_buffer = '' 
    362                  
    363                 #self.textEditDebugConsole.append(output) 
     351        def updateInterface(self): 
     352                 
     353                self.processPacketThinkGear(self.thinkGearConnectServer.protocol.data_packet) 
    364354         
    365355         
     
    368358        def processPacketThinkGear(self, packet): 
    369359                 
    370                 if self.DEBUG: 
     360                if self.DEBUG > 2: 
    371361                        print packet 
    372362                 
     
    377367                        value = 200 - packet['poorSignalLevel'] 
    378368                        self.progressBarSignalContactQuality.setValue(value) 
    379                         self.updateDebugConsole("") 
    380                         self.updateDebugConsole("poorSignalLevel: %i" % \ 
    381                                                      packet['poorSignalLevel']) 
     369                        self.textEditDebugConsole.append("") 
     370                        self.textEditDebugConsole.append("poorSignalLevel: %i" % \ 
     371                                                              packet['poorSignalLevel']) 
    382372                 
    383373                 
     
    387377                                value = packet['eSense']['attention'] 
    388378                                self.progressBarAttention.setValue(value) 
    389                                 self.updateDebugConsole("eSense attention: %i" % value) 
     379                                self.textEditDebugConsole.append("eSense attention: %i" % value) 
    390380                         
    391381                        if ('meditation' in packet['eSense'].keys()): 
    392382                                value = packet['eSense']['meditation'] 
    393383                                self.progressBarMeditation.setValue(value) 
    394                                 self.updateDebugConsole("eSense meditation: %i" % value) 
     384                                self.textEditDebugConsole.append("eSense meditation: %i" % value) 
    395385                 
    396386                 
     
    407397                                self.progressBarEEGDelta.setMaximum(self.maxEEGPower) 
    408398                                self.progressBarEEGDelta.setValue(value) 
    409                                 self.updateDebugConsole("delta: %i" % value) 
     399                                self.textEditDebugConsole.append("delta: %i" % value) 
    410400                         
    411401                        if ('theta' in packet['eegPower'].keys()): 
     
    413403                                self.progressBarEEGTheta.setMaximum(self.maxEEGPower) 
    414404                                self.progressBarEEGTheta.setValue(value) 
    415                                 self.updateDebugConsole("theta: %i" % value) 
     405                                self.textEditDebugConsole.append("theta: %i" % value) 
    416406                         
    417407                        if ('lowAlpha' in packet['eegPower'].keys()): 
     
    419409                                self.progressBarEEGLowAlpha.setMaximum(self.maxEEGPower) 
    420410                                self.progressBarEEGLowAlpha.setValue(value) 
    421                                 self.updateDebugConsole("lowAlpha: %i" % value) 
     411                                self.textEditDebugConsole.append("lowAlpha: %i" % value) 
    422412                         
    423413                        if ('highAlpha' in packet['eegPower'].keys()): 
     
    425415                                self.progressBarEEGHighAlpha.setMaximum(self.maxEEGPower) 
    426416                                self.progressBarEEGHighAlpha.setValue(value) 
    427                                 self.updateDebugConsole("highAlpha: %i" % value) 
     417                                self.textEditDebugConsole.append("highAlpha: %i" % value) 
    428418                         
    429419                        if ('lowBeta' in packet['eegPower'].keys()): 
     
    431421                                self.progressBarEEGLowBeta.setMaximum(self.maxEEGPower) 
    432422                                self.progressBarEEGLowBeta.setValue(value) 
    433                                 self.updateDebugConsole("lowBeta: %i" % value) 
     423                                self.textEditDebugConsole.append("lowBeta: %i" % value) 
    434424                         
    435425                        if ('highBeta' in packet['eegPower'].keys()): 
     
    437427                                self.progressBarEEGHighBeta.setMaximum(self.maxEEGPower) 
    438428                                self.progressBarEEGHighBeta.setValue(value) 
    439                                 self.updateDebugConsole("highBeta: %i" % value) 
     429                                self.textEditDebugConsole.append("highBeta: %i" % value) 
    440430                         
    441431                        if ('lowGamma' in packet['eegPower'].keys()): 
     
    443433                                self.progressBarEEGLowGamma.setMaximum(self.maxEEGPower) 
    444434                                self.progressBarEEGLowGamma.setValue(value) 
    445                                 self.updateDebugConsole("lowGamma: %i" % value) 
     435                                self.textEditDebugConsole.append("lowGamma: %i" % value) 
    446436                         
    447437                        if ('highGamma' in packet['eegPower'].keys()): 
     
    449439                                self.progressBarEEGMidGamma.setMaximum(self.maxEEGPower) 
    450440                                self.progressBarEEGMidGamma.setValue(value) 
    451                                 self.updateDebugConsole("highGamma: %i" % value) 
     441                                self.textEditDebugConsole.append("highGamma: %i" % value) 
    452442         
    453443         
     
    521511                if reply == QtGui.QMessageBox.Yes: 
    522512                         
     513                        self.updateInterfaceTimer.stop() 
     514                         
     515                        #if self.thinkgearConnectClient != None: 
     516                                #self.thinkgearConnectClient.disconnectFromHost() 
     517                         
    523518                        if self.thinkGearConnectServer != None: 
    524519                                self.thinkGearConnectServer.exitThread() 
  • synapse/puzzlebox_synapse_protocol_thinkgear.py

    r151 r152  
    671671                 
    672672                if 'eSense' in packet_update.keys(): 
    673                         #self.data_packet = {'eSense': {}} 
     673                        process_packet = {'eSense': {}} 
    674674                        for key in packet_update['eSense'].keys(): 
    675675                                self.data_packet['eSense'][key] = packet_update['eSense'][key] 
     676                                process_packet['eSense'][key] = packet_update['eSense'][key] 
    676677                 
    677678                else: 
    678679                        self.data_packet.update(packet_update) 
    679                         #self.data_packet = packet_update 
     680                        process_packet = packet_update 
     681                 
    680682                 
    681683                if self.DEBUG > 3: 
     
    683685                 
    684686                 
    685                 #if (self.parent != None): 
    686                         ##self.parent.processPacketThinkGear(self.data_packet) 
    687                         ##self.parent.updateStatus() 
    688                         #self.parent.timerEvent() 
     687                if (self.parent != None): 
     688                        self.parent.processPacketThinkGear(process_packet) 
    689689         
    690690         
  • synapse/puzzlebox_synapse_server_thinkgear.py

    r151 r152  
    165165                 
    166166                 
    167                 #if ((self.parent == None) or \ 
    168                          #(self.emulate_headset_data)): 
    169                 self.updateTimer = QtCore.QTimer() 
    170                 QtCore.QObject.connect(self.updateTimer, \ 
    171                                                                                 QtCore.SIGNAL("timeout()"), \ 
    172                                                                                 self.timerEvent) 
    173                 self.updateTimer.start(MESSAGE_FREQUENCY_TIMER) 
     167                if (self.emulate_headset_data): 
     168                        self.emulationTimer = QtCore.QTimer() 
     169                        QtCore.QObject.connect(self.emulationTimer, \ 
     170                                                    QtCore.SIGNAL("timeout()"), \ 
     171                                                    self.emulationEvent) 
     172                        self.emulationTimer.start(MESSAGE_FREQUENCY_TIMER) 
    174173         
    175174         
     
    201200        ################################################################## 
    202201         
    203         def timerEvent(self): 
    204                  
    205                 #if ((self.connections != []) or \ 
    206                          #(self.parent != None)): 
    207                          
     202        def emulationEvent(self): 
     203                 
    208204                self.updateStatus() 
    209205                self.sendPacketQueue() 
     
    343339         
    344340        def sendResponse(self, connection, response, disconnect_after_sending=False): 
    345  
     341                 
    346342                # Special socket handling for Flash applications 
    347343                if (response == FLASH_SOCKET_POLICY_FILE): 
     
    353349                if connection.waitForConnected(CLIENT_NO_REPLY_WAIT): 
    354350                         
    355                         if self.DEBUG: 
     351                        if self.DEBUG > 1: 
    356352                                print "<-- [%s] Sending:" % self.socket.name, 
    357353                                print data 
     
    537533        ################################################################## 
    538534         
     535        def processPacketThinkGear(self, packet): 
     536                 
     537                if self.DEBUG > 2: 
     538                        print packet 
     539                 
     540                if (packet != {}): 
     541                        self.packet_queue.append(packet) 
     542                        self.sendPacketQueue() 
     543                 
     544                #if (self.parent != None): 
     545                                #self.parent.processPacketThinkGear(self.protocol.data_packet) 
     546         
     547         
     548        ################################################################## 
     549         
    539550        def updateStatus(self): 
    540551                 
    541                 if self.emulate_headset_data: 
    542                          
    543                         # Craft a simulated data packet 
    544                         packet = self.simulateHeadsetData() 
    545                          
     552                # Craft a simulated data packet 
     553                packet = self.simulateHeadsetData() 
     554                 
     555                self.packet_queue.append(packet) 
     556                 
     557                if (self.parent != None): 
     558                        self.parent.processPacketThinkGear(packet) 
     559                 
     560                # Include simulated blinks at desired frequency 
     561                if ((self.blink_frequency_timer != None) and \ 
     562                                (self.blink_frequency_timer > 0) and \ 
     563                                (time.time() - self.blink_timestamp > \ 
     564                                self.blink_frequency_timer)): 
     565                         
     566                        self.blink_timestamp = time.time() 
     567                         
     568                        packet = DEFAULT_BLINK_MESSAGE 
    546569                        self.packet_queue.append(packet) 
    547                          
    548                         if (self.parent != None): 
    549                                 self.parent.processPacketThinkGear(packet) 
    550                          
    551                         # Include simulated blinks at desired frequency 
    552                         if ((self.blink_frequency_timer != None) and \ 
    553                             (self.blink_frequency_timer > 0) and \ 
    554                             (time.time() - self.blink_timestamp > \ 
    555                              self.blink_frequency_timer)): 
    556                                  
    557                                 self.blink_timestamp = time.time() 
    558                                  
    559                                 packet = DEFAULT_BLINK_MESSAGE 
    560                                 self.packet_queue.append(packet) 
    561                  
    562                 else: 
    563                          
    564                         #if self.protocol.data_packet != {'eegPower': {}, 'eSense': {}}: 
    565                         if self.protocol.data_packet != {}: 
    566                                 self.packet_queue.append(self.protocol.data_packet) 
    567                                  
    568                                 if (self.parent != None): 
    569                                                 self.parent.processPacketThinkGear(self.protocol.data_packet) 
    570570         
    571571         
     
    585585                 
    586586                try: 
    587                         self.updateTimer.stop() 
     587                        self.emulationTimer.stop() 
    588588                except: 
    589589                        pass 
Note: See TracChangeset for help on using the changeset viewer.