Changeset 147


Ignore:
Timestamp:
08/06/10 11:51:41 (11 years ago)
Author:
sc
Message:

synapse/puzzlebox_synapse_server_thinkgear.py:

  • renamed from puzzlebox_synapse_server.py

synapse/puzzlebox_synapse_configuration:

  • THINKGEAR_EMULATION_MAX_ESENSE_VALUE added
  • THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE added
  • THINKGEAR_EEG_POWER_MULTIPLIERS added

synapse/puzzlebox_synapse_protocol_thinkgear.py:

  • parent tracking

synapse/puzzlebox_synapse_interface.py:

  • ThinkGear? packet processing complete
  • progress bar display complete
  • legacy code cleanup
Location:
synapse
Files:
4 edited
1 moved

Legend:

Unmodified
Added
Removed
  • synapse/puzzlebox_synapse_configuration.ini

    r146 r147  
    4949                                         # detection value below 
    5050 
    51 THINKGEAR_ATTENTION_MULTIPLIER = 1.0 # Multipliers allow fine tuning 
    52  
     51THINKGEAR_ATTENTION_MULTIPLIER = 1.0 # Multipliers allow fine tuning emulation 
    5352THINKGEAR_MEDITATION_MULTIPLIER = 0.75 
    5453 
     54THINKGEAR_EEG_POWER_MULTIPLIERS = { 'delta': 0.25, 'theta': 0.4, 'lowAlpha': 0.6, 'highAlpha': 0.8, 'lowBeta': 0.9, 'highBeta': 1.0, 'lowGamma': 0.75, 'highGamma': 0.5 } 
     55 
     56 
  • synapse/puzzlebox_synapse_configuration.py

    r146 r147  
    99# For more information please refer to http://www.gnu.org/copyleft/gpl.html 
    1010# 
    11 # Last Update: 2010.08.04 
     11# Last Update: 2010.08.05 
    1212# 
    1313##################################################################### 
     
    7373        } 
    7474 
     75THINKGEAR_EMULATION_MAX_ESENSE_VALUE = 100 
     76THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE = 65535 
     77 
    7578THINKGEAR_ATTENTION_MULTIPLIER = 1.0 
     79THINKGEAR_MEDITATION_MULTIPLIER = 1.0 
    7680 
    77 THINKGEAR_MEDITATION_MULTIPLIER = 1.0 
     81THINKGEAR_EEG_POWER_MULTIPLIERS = { \ 
     82        'delta': 1.0, \ 
     83        'theta': 1.0, \ 
     84        'lowAlpha': 1.0, \ 
     85        'highAlpha': 1.0, \ 
     86        'lowBeta': 1.0, \ 
     87        'highBeta': 1.0, \ 
     88        'lowGamma': 1.0, \ 
     89        'highGamma': 1.0, \ 
     90} 
    7891 
    7992 
  • synapse/puzzlebox_synapse_interface.py

    r146 r147  
    3535 
    3636import puzzlebox_synapse_configuration as configuration 
    37 import puzzlebox_synapse_server as synapse_server 
     37import puzzlebox_synapse_server_thinkgear as synapse_server 
    3838#import puzzlebox_logger 
    3939 
     
    5555THINKGEAR_SERVER_PORT = configuration.THINKGEAR_SERVER_PORT 
    5656 
     57THINKGEAR_EMULATION_MAX_ESENSE_VALUE = \ 
     58        configuration.THINKGEAR_EMULATION_MAX_ESENSE_VALUE 
     59THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE = \ 
     60        configuration.THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE 
     61 
    5762##################################################################### 
    5863# Classes 
     
    7681                self.thinkGearConnectServer = None 
    7782                 
    78                 #self.brainstormsServer = server 
    79                 #self.brainstormsClient = None 
    80                  
    81                 #self.drive_state = 'stop_motors' 
    82                 #self.current_speed = 0 
     83                self.maxEEGPower = THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE 
     84 
    8385         
    8486         
     
    110112                # Display Port for ThinkGear Connect Socket Server 
    111113                self.lineEditThinkGearPort.setText('%i' % THINKGEAR_SERVER_PORT) 
     114                 
     115                 
     116                # ThinkgGear Progress Bars 
     117                self.progressBarEEGDelta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
     118                self.progressBarEEGTheta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
     119                self.progressBarEEGLowAlpha.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
     120                self.progressBarEEGHighAlpha.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
     121                self.progressBarEEGLowBeta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
     122                self.progressBarEEGHighBeta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
     123                self.progressBarEEGLowGamma.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
     124                self.progressBarEEGMidGamma.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
     125                 
     126                self.progressBarAttention.setMaximum(THINKGEAR_EMULATION_MAX_ESENSE_VALUE) 
     127                self.progressBarMeditation.setMaximum(THINKGEAR_EMULATION_MAX_ESENSE_VALUE) 
     128                 
     129                self.progressBarSignalContactQuality.setMaximum(200) 
    112130         
    113131         
     
    219237                         
    220238                        self.thinkGearConnectServer = \ 
    221                                 synapse_server.puzzlebox_synapse_server( \ 
     239                                synapse_server.puzzlebox_synapse_server_thinkgear( \ 
    222240                                        log, \ 
    223241                                        server_interface=server_interface, \ 
     
    269287        ################################################################## 
    270288         
    271         def getMinimumThreshold(self, threshold): 
    272                  
    273                 '''Return the minimum detection level which results 
    274                 in a non-zero power setting''' 
    275                  
    276                 minimum = 100 
    277                  
    278                 threshold_keys = threshold.keys() 
    279                 threshold_keys.sort() 
    280                 threshold_keys.reverse() 
    281                  
    282                 for key in threshold_keys: 
    283                          
    284                         if ((threshold[key] < minimum) and \ 
    285                                  (threshold[key] > 0)): 
    286                                 minimum = key 
    287                  
    288                  
    289                 return(minimum) 
    290          
    291          
    292         ################################################################## 
    293          
    294         def configureNetworkBrainstorms(self): 
    295                  
    296                 bluetooth_device = self.lineEditNXTPort.text() 
    297                  
    298                 self.brainstormsClient = \ 
    299                    brainstorms_client.puzzlebox_brainstorms_network_client( \ 
    300                            self.log, \ 
    301                            bluetooth_device=bluetooth_device, \ 
    302                            parent=self) 
    303                  
    304                 self.brainstormsClient.sendCommand('connect', \ 
    305                                                    bluetooth_device=bluetooth_device) 
    306          
    307          
    308         ################################################################## 
    309          
    310         def connectToBrainstormsServer(self): 
     289        def processPacketThinkGear(self, packet): 
    311290                 
    312291                if self.DEBUG: 
    313                         print "<---- [%s] Connecting to Brainstorms Server" % self.name 
    314                  
    315                 self.configureNetworkBrainstorms() 
    316                  
    317                 #if (self.brainstormsClient.socket.state() != QtNetwork.QAbstractSocket.ConnectedState): 
    318                         #QtGui.QMessageBox.information(self, \ 
    319                                                                 #self.brainstormsClient.socket.name, \ 
    320                                            #"Failed to connect to Brainstorms socket server") 
    321                  
    322                 #else: 
    323                 self.disconnect(self.pushButtonNXTConnect, \ 
    324                                                         QtCore.SIGNAL("clicked()"), \ 
    325                                                         self.connectToBrainstormsServer) 
    326                  
    327                 self.connect(self.pushButtonNXTConnect, \ 
    328                                                         QtCore.SIGNAL("clicked()"), \ 
    329                                                         self.disconnectFromBrainstormsServer) 
    330                  
    331                 self.textLabelNXTStatus.setText("Status: Connected") 
    332                 self.pushButtonNXTConnect.setText('Disconnect') 
    333                  
    334                 self.lineEditNXTPort.setEnabled(False) 
    335                  
    336                 self.pushButtonTurnLeft.setEnabled(True) 
    337                 self.pushButtonForward.setEnabled(True) 
    338                 self.pushButtonTurnRight.setEnabled(True) 
    339                 self.pushButtonTurnLeftReverse.setEnabled(True) 
    340                 self.pushButtonReverse.setEnabled(True) 
    341                 self.pushButtonTurnRightReverse.setEnabled(True) 
    342          
    343          
    344         ################################################################## 
    345          
    346         def disconnectFromBrainstormsServer(self): 
    347                  
    348                 if self.DEBUG: 
    349                         print "- - [%s] Disconnecting from Brainstorms Server" % self.name 
    350                  
    351                 self.stopMotors() 
    352                  
    353                 # Ensure the stopMotors command has been received by the server 
    354                 # so the NXT robot will stop before the client disconnects 
    355                 self.brainstormsClient.socket.flush() 
    356                  
    357                 self.brainstormsClient.socket.disconnectFromHost() 
    358                  
    359                 self.disconnect(self.pushButtonNXTConnect, \ 
    360                                   QtCore.SIGNAL("clicked()"), \ 
    361                                   self.disconnectFromBrainstormsServer) 
    362                  
    363                 self.connect(self.pushButtonNXTConnect, \ 
    364                                   QtCore.SIGNAL("clicked()"), \ 
    365                                   self.connectToBrainstormsServer) 
    366                  
    367                 self.textLabelNXTStatus.setText("Status: Disconnected") 
    368                 self.pushButtonNXTConnect.setText('Connect') 
    369                  
    370                 self.lineEditNXTPort.setEnabled(True) 
    371                  
    372                 self.pushButtonTurnLeft.setEnabled(False) 
    373                 self.pushButtonForward.setEnabled(False) 
    374                 self.pushButtonTurnRight.setEnabled(False) 
    375                 self.pushButtonTurnLeftReverse.setEnabled(False) 
    376                 self.pushButtonReverse.setEnabled(False) 
    377                 self.pushButtonTurnRightReverse.setEnabled(False) 
    378                  
    379                 self.brainstormsClient = None 
    380          
    381          
    382         ################################################################## 
    383          
    384         def connectToThinkGearHost(self): 
    385                  
    386                 if self.DEBUG: 
    387                         print "Connecting to ThinkGear Host" 
    388                  
    389                 server_host = str(self.lineEditThinkGearHost.text()) 
    390                 server_port = int(self.lineEditThinkGearPort.text()) 
    391                  
    392                 self.thinkgearClient = \ 
    393                    thinkgear_client.puzzlebox_brainstorms_network_client_thinkgear( \ 
    394                            self.log, \ 
    395                            server_host=server_host, \ 
    396                            server_port=server_port, \ 
    397                            DEBUG=0, \ 
    398                            parent=self) 
    399                  
    400                 if (self.thinkgearClient.socket.state() != QtNetwork.QAbstractSocket.ConnectedState): 
    401                         QtGui.QMessageBox.information(self, \ 
    402                                                                 self.thinkgearClient.socket.name, \ 
    403                                            "Failed to connect to ThinkGear socket server") 
    404                  
    405                 else: 
    406                         self.disconnect(self.pushButtonThinkGearConnect, \ 
    407                                                          QtCore.SIGNAL("clicked()"), \ 
    408                                                          self.connectToThinkGearHost) 
    409                          
    410                         self.connect(self.pushButtonThinkGearConnect, \ 
    411                                                          QtCore.SIGNAL("clicked()"), \ 
    412                                                          self.disconnectFromThinkGearHost) 
    413                          
    414                         self.pushButtonThinkGearConnect.setText('Disconnect') 
    415                          
    416                         self.lineEditThinkGearHost.setEnabled(False) 
    417                         self.lineEditThinkGearPort.setEnabled(False) 
    418          
    419          
    420         ################################################################## 
    421          
    422         def disconnectFromThinkGearHost(self): 
    423                  
    424                 if self.DEBUG: 
    425                         print "Disconnecting from ThinkGear Host" 
    426                  
    427                 self.thinkgearClient.disconnectFromHost() 
    428                  
    429                 self.disconnect(self.pushButtonThinkGearConnect, \ 
    430                                   QtCore.SIGNAL("clicked()"), \ 
    431                                   self.disconnectFromThinkGearHost) 
    432                  
    433                 self.connect(self.pushButtonThinkGearConnect, \ 
    434                                   QtCore.SIGNAL("clicked()"), \ 
    435                                   self.connectToThinkGearHost) 
    436                  
    437                 self.pushButtonForward.emit(QtCore.SIGNAL("released()")) 
    438                  
    439                 self.pushButtonThinkGearConnect.setText('Connect') 
    440                  
    441                 self.lineEditThinkGearHost.setEnabled(True) 
    442                 self.lineEditThinkGearPort.setEnabled(True) 
    443                  
    444                 self.progressBarConcentration.setValue(0) 
    445                 self.progressBarRelaxation.setValue(0) 
    446                 self.progressBarSpeed.setValue(0) 
    447          
    448          
    449         ################################################################## 
    450          
    451         def updateConcentrationButton(self): 
    452                  
    453                 if self.pushButtonConcentrationEnable.isChecked(): 
    454                          
    455                         self.pushButtonConcentrationEnable.setText('Enabled') 
    456                  
    457                 else: 
    458                          
    459                         self.pushButtonConcentrationEnable.setText('Disabled') 
    460                         self.progressBarConcentration.setValue(0) 
    461                  
    462                  
    463                 self.updateSpeed() 
    464          
    465          
    466         ################################################################## 
    467          
    468         def updateRelaxationButton(self): 
    469                  
    470                 if self.pushButtonRelaxationEnable.isChecked(): 
    471                  
    472                         self.pushButtonRelaxationEnable.setText('Enabled') 
    473                  
    474                 else: 
    475                          
    476                         self.pushButtonRelaxationEnable.setText('Disabled') 
    477                         self.progressBarRelaxation.setValue(0) 
    478                  
    479                  
    480                 self.updateSpeed() 
    481          
    482          
    483         ################################################################## 
    484          
    485         def updateSpeedButton(self): 
    486                  
    487                 if self.pushButtonSpeedEnable.isChecked(): 
    488                  
    489                         self.pushButtonSpeedEnable.setText('Enabled') 
    490                         self.updateSpeed() 
    491                  
    492                 else: 
    493                          
    494                         self.pushButtonSpeedEnable.setText('Disabled') 
    495                         self.progressBarSpeed.setValue(0) 
    496                         self.stopMotors() 
    497          
    498          
    499         ################################################################## 
    500          
    501         def updateSpeed(self, new_speed=None): 
    502                  
    503                 if new_speed == None: 
    504                  
    505                         concentration=self.progressBarConcentration.value() 
    506                         relaxation=self.progressBarRelaxation.value() 
    507                          
    508                         new_speed = self.calculateSpeed(concentration, relaxation) 
    509                  
    510                  
    511                 # Update GUI 
    512                 if self.pushButtonSpeedEnable.isChecked(): 
    513                         self.progressBarSpeed.setValue(new_speed) 
    514                  
    515                  
    516                 # If there is a change between the new and current speeds 
    517                 # and either the robot is currently driving forward 
    518                 # or the "speed control" button is enabled, 
    519                 # then send the updated speed to the robot 
    520                 if ((self.current_speed != new_speed) and \ 
    521                          ((self.drive_state == 'drive_forward') or \ 
    522                           (self.pushButtonSpeedEnable.isChecked()))): 
    523                          
    524                         if (new_speed == 0): 
    525                                 self.current_speed = new_speed 
    526                                 self.stopMotors() 
    527                         else: 
    528                                 if ((self.brainstormsClient != None) and \ 
    529                                     (self.pushButtonSpeedEnable.isChecked())): 
    530                                         self.pushButtonForward.setDown(True) 
    531                                         self.brainstormsClient.sendCommand('drive_forward', power=new_speed) 
    532                  
    533                  
    534                 self.current_speed = new_speed 
    535          
    536          
    537         ################################################################## 
    538          
    539         def calculateSpeed(self, concentration, relaxation): 
    540                  
    541                 speed = 0 
    542                  
    543                 thresholds = THINKGEAR_POWER_THRESHOLDS 
    544                  
    545                 match = int(concentration) 
    546                  
    547                 while ((match not in thresholds['concentration'].keys()) and \ 
    548                             (match >= 0)): 
    549                         match -= 1 
    550                  
    551                  
    552                 if match in thresholds['concentration'].keys(): 
    553                         speed = thresholds['concentration'][match] 
    554                  
    555                  
    556                 match = int(relaxation) 
    557                  
    558                 while ((match not in thresholds['relaxation'].keys()) and \ 
    559                             (match >= 0)): 
    560                         match -= 1 
    561                  
    562                 if match in thresholds['relaxation'].keys(): 
    563                         speed = speed + thresholds['relaxation'][match] 
    564                  
    565                  
    566                 # LEGO Mindstorms power settings cannot exceed 100 
    567                 # and don't drive well with levels less than 50 
    568                 if (speed > 100): 
    569                         speed = 100 
    570                 elif (speed < 50): 
    571                         speed = 0 
    572                  
    573                  
    574                 return(speed) 
    575          
    576          
    577         ################################################################## 
    578          
    579         def processPacketThinkGear(self, packet): 
     292                        print packet 
     293                 
     294                self.textEditDebugConsole.append( str(packet) ) 
     295                 
     296                 
     297                if ('poorSignalLevel' in packet.keys()): 
     298                        value = 200 - packet['poorSignalLevel'] 
     299                        self.progressBarSignalContactQuality.setValue(value) 
     300                 
    580301                 
    581302                if ('eSense' in packet.keys()): 
    582303                         
    583304                        if ('attention' in packet['eSense'].keys()): 
    584                                 if self.pushButtonConcentrationEnable.isChecked(): 
    585                                         self.progressBarConcentration.setValue(packet['eSense']['attention']) 
     305                                value = packet['eSense']['attention'] 
     306                                self.progressBarAttention.setValue(value) 
    586307                         
    587308                        if ('meditation' in packet['eSense'].keys()): 
    588                                 if self.pushButtonRelaxationEnable.isChecked(): 
    589                                         self.progressBarRelaxation.setValue(packet['eSense']['meditation']) 
    590                  
    591                  
    592                 self.updateSpeed() 
     309                                value = packet['eSense']['meditation'] 
     310                                self.progressBarMeditation.setValue(value) 
     311                 
     312                 
     313                if ('eegPower' in packet.keys()): 
     314                         
     315                         
     316                        for value in packet['eegPower'].keys(): 
     317                                if packet['eegPower'][value] > self.maxEEGPower: 
     318                                        self.maxEEGPower = packet['eegPower'][value] 
     319                         
     320                         
     321                        if ('delta' in packet['eegPower'].keys()): 
     322                                value = packet['eegPower']['delta'] 
     323                                self.progressBarEEGDelta.setMaximum(self.maxEEGPower) 
     324                                self.progressBarEEGDelta.setValue(value) 
     325                         
     326                        if ('theta' in packet['eegPower'].keys()): 
     327                                value = packet['eegPower']['theta'] 
     328                                self.progressBarEEGTheta.setMaximum(self.maxEEGPower) 
     329                                self.progressBarEEGTheta.setValue(value) 
     330                         
     331                        if ('lowAlpha' in packet['eegPower'].keys()): 
     332                                value = packet['eegPower']['lowAlpha'] 
     333                                self.progressBarEEGLowAlpha.setMaximum(self.maxEEGPower) 
     334                                self.progressBarEEGLowAlpha.setValue(value) 
     335                         
     336                        if ('highAlpha' in packet['eegPower'].keys()): 
     337                                value = packet['eegPower']['highAlpha'] 
     338                                self.progressBarEEGHighAlpha.setMaximum(self.maxEEGPower) 
     339                                self.progressBarEEGHighAlpha.setValue(value) 
     340                         
     341                        if ('lowBeta' in packet['eegPower'].keys()): 
     342                                value = packet['eegPower']['lowBeta'] 
     343                                self.progressBarEEGLowBeta.setMaximum(self.maxEEGPower) 
     344                                self.progressBarEEGLowBeta.setValue(value) 
     345                         
     346                        if ('highBeta' in packet['eegPower'].keys()): 
     347                                value = packet['eegPower']['highBeta'] 
     348                                self.progressBarEEGHighBeta.setMaximum(self.maxEEGPower) 
     349                                self.progressBarEEGHighBeta.setValue(value) 
     350                         
     351                        if ('lowGamma' in packet['eegPower'].keys()): 
     352                                value = packet['eegPower']['lowGamma'] 
     353                                self.progressBarEEGLowGamma.setMaximum(self.maxEEGPower) 
     354                                self.progressBarEEGLowGamma.setValue(value) 
     355                         
     356                        if ('highGamma' in packet['eegPower'].keys()): 
     357                                value = packet['eegPower']['highGamma'] 
     358                                self.progressBarEEGMidGamma.setMaximum(self.maxEEGPower) 
     359                                self.progressBarEEGMidGamma.setValue(value) 
    593360         
    594361         
  • synapse/puzzlebox_synapse_protocol_thinkgear.py

    r146 r147  
    133133                self.log = log 
    134134                self.DEBUG = DEBUG 
     135                self.parent = parent 
    135136                 
    136137                self.device = None 
  • synapse/puzzlebox_synapse_server_thinkgear.py

    r146 r147  
    5959DEFAULT_SAMPLE_WAVELENGTH = configuration.THINKGEAR_DEFAULT_SAMPLE_WAVELENGTH 
    6060 
     61THINKGEAR_EMULATION_MAX_ESENSE_VALUE = configuration.THINKGEAR_EMULATION_MAX_ESENSE_VALUE 
     62 
    6163THINKGEAR_ATTENTION_MULTIPLIER = configuration.THINKGEAR_ATTENTION_MULTIPLIER 
    62  
    6364THINKGEAR_MEDITATION_MULTIPLIER = configuration.THINKGEAR_MEDITATION_MULTIPLIER 
     65 
     66THINKGEAR_EEG_POWER_MULTIPLIERS = configuration.THINKGEAR_EEG_POWER_MULTIPLIERS 
    6467 
    6568DEFAULT_AUTHORIZATION_MESSAGE = \ 
     
    120123##################################################################### 
    121124 
    122 class puzzlebox_synapse_server(QtCore.QThread): 
     125class puzzlebox_synapse_server_thinkgear(QtCore.QThread): 
    123126         
    124127        def __init__(self, log, \ 
     
    134137                self.log = log 
    135138                self.DEBUG = DEBUG 
     139                self.parent = parent 
    136140                 
    137141                self.server_interface = server_interface 
     
    175179                              self.log, \ 
    176180                              device_address=self.device_address, \ 
    177                               DEBUG=self.DEBUG) 
     181                              DEBUG=self.DEBUG, \ 
     182                              parent=self.parent) 
    178183                         
    179184                        self.serial_device.start() 
     
    183188                              self.log, \ 
    184189                              self.serial_device, \ 
    185                               DEBUG=self.DEBUG) 
     190                              DEBUG=self.DEBUG, \ 
     191                              parent=self.parent) 
    186192                         
    187193                        self.protocol.start() 
     
    192198        def timerEvent(self): 
    193199                 
    194                 if (self.connections != []): 
     200                if ((self.connections != []) or \ 
     201                         (self.parent != None)): 
    195202                         
    196203                        self.updateStatus() 
     
    510517                                 
    511518                                for each in response[key].keys(): 
    512                                         response[key][each] = plot 
     519                                        if ((THINKGEAR_EEG_POWER_MULTIPLIERS != None) and \ 
     520                                                 (each in THINKGEAR_EEG_POWER_MULTIPLIERS.keys())): 
     521                                                value = THINKGEAR_EEG_POWER_MULTIPLIERS[each] * plot 
     522                                        else: 
     523                                                value = plot 
     524                                        response[key][each] = value 
    513525                 
    514526                 
     
    523535                         
    524536                        # Craft a simulated data packet 
    525                         self.packet_queue.append( \ 
    526                                 self.simulateHeadsetData() ) 
     537                        packet = self.simulateHeadsetData() 
     538                         
     539                        self.packet_queue.append(packet) 
     540                         
     541                        if (self.parent != None): 
     542                                self.parent.processPacketThinkGear(packet) 
    527543                         
    528544                        # Include simulated blinks at desired frequency 
     
    556572         
    557573        def exitThread(self, callThreadQuit=True): 
     574                 
     575                self.updateTimer.stop() 
    558576                 
    559577                if self.serial_device != None: 
     
    616634        app = QtCore.QCoreApplication(sys.argv) 
    617635         
    618         server = puzzlebox_synapse_server(log, \ 
    619                                           server_interface, \ 
    620                                           server_port, \ 
    621                                           device_address, \ 
    622                                           emulate_headset_data = \ 
    623                                              ENABLE_SIMULATE_HEADSET_DATA, \ 
    624                                           DEBUG=DEBUG) 
     636        server = puzzlebox_synapse_server_thinkgear( \ 
     637                         log, \ 
     638                         server_interface, \ 
     639                         server_port, \ 
     640                         device_address, \ 
     641                         emulate_headset_data = \ 
     642                            ENABLE_SIMULATE_HEADSET_DATA, \ 
     643                         DEBUG=DEBUG) 
    625644         
    626645        server.start() 
Note: See TracChangeset for help on using the changeset viewer.