Changeset 372


Ignore:
Timestamp:
04/02/12 04:57:39 (8 years ago)
Author:
sc
Message:

Device:

  • breakout from Session
Location:
trunk/Puzzlebox/Synapse
Files:
1 added
2 edited

Legend:

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

    r371 r372  
    6464from Interface_Design import Ui_Form as Design 
    6565 
     66import Puzzlebox.Synapse.Device as synapse_device 
    6667import Puzzlebox.Synapse.Session as synapse_session 
    6768import Puzzlebox.Synapse.Client as synapse_client 
     
    112113 
    113114#class puzzlebox_synapse_interface(QtGui.QWidget, Design, Puzzlebox.Synapse.Session.puzzlebox_synapse_session): 
    114 class puzzlebox_synapse_interface(synapse_session.puzzlebox_synapse_session, Design): 
     115class puzzlebox_synapse_interface(synapse_device.puzzlebox_synapse_device, \ 
     116                                  synapse_session.puzzlebox_synapse_session, \ 
     117                                  Design): 
    115118         
    116119        def __init__(self, log, \ 
  • trunk/Puzzlebox/Synapse/Session.py

    r371 r372  
    1111 
    1212__todo__ = """ 
    13 - update configuration.ini file with settings entered into interface 
    1413""" 
    1514 
     
    2827                configuration.ENABLE_PYSIDE = False 
    2928        else: 
    30                 print "INFO: [Synapse:Interface] Using PySide module" 
     29                print "INFO: [Synapse:Session] Using PySide module" 
    3130 
    3231if not configuration.ENABLE_PYSIDE: 
    33         print "INFO: [Synapse:Interface] Using PyQt4 module" 
     32        print "INFO: [Synapse:Session] Using PyQt4 module" 
    3433        from PyQt4 import QtCore, QtGui, QtNetwork 
    3534 
     
    4746DEBUG = configuration.DEBUG 
    4847 
    49 SYNAPSE_SERVER_HOST = configuration.SYNAPSE_SERVER_HOST 
    50 SYNAPSE_SERVER_PORT = configuration.SYNAPSE_SERVER_PORT 
    51  
    52 EMULATE_THINKGEAR_FOR_EMOTIV = configuration.EMULATE_THINKGEAR_FOR_EMOTIV 
     48#SYNAPSE_SERVER_HOST = configuration.SYNAPSE_SERVER_HOST 
     49#SYNAPSE_SERVER_PORT = configuration.SYNAPSE_SERVER_PORT 
     50 
     51#EMULATE_THINKGEAR_FOR_EMOTIV = configuration.EMULATE_THINKGEAR_FOR_EMOTIV 
    5352 
    5453PATH_TO_HCITOOL = '/usr/bin/hcitool' 
     
    179178        ################################################################## 
    180179         
    181         def enumerateSerialPorts(self): 
    182                  
    183                 """ Uses the Win32 registry to return an 
    184                 iterator of serial (COM) ports 
    185                 existing on this computer. 
    186                  
    187                 from http://eli.thegreenplace.net/2009/07/31/listing-all-serial-ports-on-windows-with-python/ 
    188                 """ 
     180        #def enumerateSerialPorts(self): 
     181                 
     182                #""" Uses the Win32 registry to return an 
     183                #iterator of serial (COM) ports 
     184                #existing on this computer. 
     185                 
     186                #from http://eli.thegreenplace.net/2009/07/31/listing-all-serial-ports-on-windows-with-python/ 
     187                #""" 
    189188          
    190                 path = 'HARDWARE\\DEVICEMAP\\SERIALCOMM' 
    191                 try: 
    192                         key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path) 
    193                 except WindowsError: 
    194                         #raise IterationError 
    195                         return 
    196                  
    197                 for i in itertools.count(): 
    198                         try: 
    199                                 val = winreg.EnumValue(key, i) 
    200                                 yield str(val[1]) 
    201                         except EnvironmentError: 
    202                                 break 
    203          
    204          
    205         ################################################################## 
    206          
    207         def fullPortName(self, portname): 
    208                  
    209                 """ Given a port-name (of the form COM7, 
    210                 COM12, CNCA0, etc.) returns a full 
    211                 name suitable for opening with the 
    212                 Serial class. 
    213                 """ 
    214                  
    215                 m = re.match('^COM(\d+)$', portname) 
    216                 if m and int(m.group(1)) < 10: 
    217                         return portname 
    218                  
    219                 return '\\\\.\\' + portname 
    220          
    221          
    222         ################################################################## 
    223          
    224         def searchForSerialDevices(self, devices=[]): 
    225                  
    226                 if (sys.platform == 'win32'): 
    227                          
    228                         for portname in self.enumerateSerialPorts(): 
    229                                  
    230                                 if portname not in devices: 
    231                                         #portname = self.fullPortName(portname) 
    232                                         devices.append(portname) 
    233                  
    234                 else: 
    235                          
    236                          
    237                         if os.path.exists('/dev/tty.MindWaveMobile-SPPDev'): 
    238                                 devices.append('/dev/tty.MindWaveMobile-SPPDev') 
    239                          
    240                         if os.path.exists('/dev/tty.MindWave'): 
    241                                 devices.append('/dev/tty.MindWave') 
    242                         if os.path.exists('/dev/tty.MindWave1'): 
    243                                 devices.append('/dev/tty.MindWave1') 
    244                         if os.path.exists('/dev/tty.MindWave2'): 
    245                                 devices.append('/dev/tty.MindWave2') 
    246                         if os.path.exists('/dev/tty.MindWave3'): 
    247                                 devices.append('/dev/tty.MindWave3') 
    248                         if os.path.exists('/dev/tty.MindWave4'): 
    249                                 devices.append('/dev/tty.MindWave4') 
    250                         if os.path.exists('/dev/tty.MindWave5'): 
    251                                 devices.append('/dev/tty.MindWave5') 
    252                          
    253                         if os.path.exists('/dev/tty.MindSet-DevB'): 
    254                                 devices.append('/dev/tty.MindSet-DevB') 
    255                          
    256                         if os.path.exists('/dev/ttyUSB0'): 
    257                                 devices.append('/dev/ttyUSB0') 
    258                         if os.path.exists('/dev/ttyUSB1'): 
    259                                 devices.append('/dev/ttyUSB1') 
    260                         if os.path.exists('/dev/ttyUSB2'): 
    261                                 devices.append('/dev/ttyUSB2') 
    262                         if os.path.exists('/dev/ttyUSB3'): 
    263                                 devices.append('/dev/ttyUSB3') 
    264                         if os.path.exists('/dev/ttyUSB4'): 
    265                                 devices.append('/dev/ttyUSB4') 
    266                         if os.path.exists('/dev/ttyUSB5'): 
    267                                 devices.append('/dev/ttyUSB5') 
    268                         if os.path.exists('/dev/ttyUSB6'): 
    269                                 devices.append('/dev/ttyUSB6') 
    270                         if os.path.exists('/dev/ttyUSB7'): 
    271                                 devices.append('/dev/ttyUSB7') 
    272                         if os.path.exists('/dev/ttyUSB8'): 
    273                                 devices.append('/dev/ttyUSB8') 
    274                         if os.path.exists('/dev/ttyUSB9'): 
    275                                 devices.append('/dev/ttyUSB9') 
    276                          
    277                         if os.path.exists('/dev/rfcomm0'): 
    278                                 devices.append('/dev/rfcomm0') 
    279                         if os.path.exists('/dev/rfcomm1'): 
    280                                 devices.append('/dev/rfcomm1') 
    281                         if os.path.exists('/dev/rfcomm2'): 
    282                                 devices.append('/dev/rfcomm2') 
    283                         if os.path.exists('/dev/rfcomm3'): 
    284                                 devices.append('/dev/rfcomm3') 
    285                         if os.path.exists('/dev/rfcomm4'): 
    286                                 devices.append('/dev/rfcomm4') 
    287                          
    288                         if os.path.exists('/dev/ttyACM0'): 
    289                                 devices.append('/dev/ttyACM0') 
    290                         if os.path.exists('/dev/ttyACM1'): 
    291                                 devices.append('/dev/ttyACM1') 
    292                         if os.path.exists('/dev/ttyACM2'): 
    293                                 devices.append('/dev/ttyACM2') 
    294                         if os.path.exists('/dev/ttyACM3'): 
    295                                 devices.append('/dev/ttyACM3') 
    296                         if os.path.exists('/dev/ttyACM4'): 
    297                                 devices.append('/dev/ttyACM4') 
    298                  
    299                  
    300                 return(devices) 
    301          
    302          
    303         ################################################################## 
    304          
    305         def hcitoolScanForRemoteDevices(self, devices=[]): 
    306                  
    307                 bluetooth_devices = [] 
    308                  
    309                 #command = '%s scan 2> /dev/null' % PATH_TO_HCITOOL 
    310                 command = '%s scan' % PATH_TO_HCITOOL 
    311                  
    312                 if self.DEBUG > 1: 
    313                         print 'INFO: Calling "%s"' % command  
    314                  
    315                 output = os.popen(command, 'r') 
    316                  
    317                 try: 
    318                         result = output.readlines() 
    319                 except Exception, e: 
    320                         if self.DEBUG: 
    321                                 print "ERROR [Synapse-Interface]: Failed reading result from call to hcitool:", 
    322                                 print e 
    323                         result = '' 
    324                  
    325                 if result == '': 
    326                         return([]) # Under OS X hcitool doesn't exist so we don't see any devices 
    327                  
    328                 for line in result: 
    329                         line = line.strip() 
    330                         if line == '' or line == 'Scanning ...': 
    331                                 continue 
    332                         elif self.DEBUG > 1: 
    333                                 print line 
    334                         try: 
    335                                 address = line.split('\t')[0] 
    336                         except: 
    337                                 pass 
    338                         else: 
    339                                 bluetooth_devices.append(address) 
    340                  
    341                  
    342                 for address in bluetooth_devices: 
    343                          
    344                         command = '%s name %s' % (PATH_TO_HCITOOL, address) 
    345                          
    346                         if self.DEBUG: 
    347                                 print 'INFO: Calling "%s"' % command 
    348                          
    349                         output = os.popen(command, 'r') 
    350                          
    351                         for line in output.readlines(): 
    352                                 line = line.strip() 
    353                                 if line == '': 
    354                                         continue 
    355                                 elif self.DEBUG: 
    356                                         print '\t', 
    357                                         print line 
    358                                  
    359                                 device_name = line.strip() 
    360                          
    361                                 if ((device_name == 'MindSet' or device_name == 'MindWave Mobile') and \ 
    362                                         (address not in devices)): 
    363                                         devices.append(address) 
    364                                  
    365                                 else: 
    366                                         if self.DEBUG: 
    367                                                 print 'INFO: Found but not recognized: [%s] %s' % \ 
    368                                                         (address, device_name) 
    369                  
    370                  
    371                 return (devices) 
    372          
    373          
    374         ################################################################## 
    375          
    376         def hcitoolGetActiveConnections(self, devices=[]): 
    377                  
    378                 bluetooth_devices = [] 
    379                  
    380                 #command = '%s con 2> /dev/null' % PATH_TO_HCITOOL 
    381                 command = '%s con' % PATH_TO_HCITOOL 
    382                  
    383                 if self.DEBUG > 1: 
    384                         print 'INFO: Calling "%s"' % command  
    385                  
    386                 output = os.popen(command, 'r') 
    387                  
    388                 try: 
    389                         result = output.readlines() 
    390                 except Exception, e: 
    391                         if self.DEBUG: 
    392                                 print "ERROR [Synapse:Interface]: Failed reading result from call to hcitool:", 
    393                                 print e 
    394                         result = '' 
    395  
    396                 if result == '': 
    397                         return([]) # Under OS X hcitool doesn't exist so we don't see any devices 
    398  
    399                 for line in result: 
    400                         line = line.strip() 
    401                         if line == '' or line == 'Connections:': 
    402                                 continue 
    403                         elif self.DEBUG > 1: 
    404                                 print line 
    405                         try: 
    406                                 address = line.split(' ')[2] 
    407                         except: 
    408                                 pass 
    409                         else: 
    410                                 bluetooth_devices.append(address) 
    411                  
    412                  
    413                 for address in bluetooth_devices: 
    414                          
    415                         command = '%s name %s' % (PATH_TO_HCITOOL, address) 
    416                          
    417                         if self.DEBUG: 
    418                                 print 'INFO: Calling "%s":' % command 
    419                          
    420                         output = os.popen(command, 'r') 
    421                          
    422                         for line in output.readlines(): 
    423                                 line = line.strip() 
    424                                 if line == '': 
    425                                         continue 
    426                                 elif self.DEBUG: 
    427                                         print '\t', 
    428                                         print line 
    429                                  
    430                                 device_name = line.strip() 
    431                          
    432                                 if ((device_name == 'MindSet' or device_name == 'MindWave Mobile') and \ 
    433                                         (address not in devices)): 
    434                                         devices.append(address) 
    435                  
    436                  
    437                 return (devices) 
    438          
    439          
    440         ################################################################## 
    441          
    442         def searchForDevices(self): 
    443                  
    444                 enable_hcitool = configuration.ENABLE_HCITOOL 
    445                  
    446                 devices = [] 
    447                  
    448                 #self.pushButtonBluetoothSearch.setText('Searching') 
    449                  
    450                 if ((sys.platform != 'win32' and sys.platform != 'darwin') and \ 
    451                      configuration.THINKGEAR_BLUETOOTH_SEARCH): 
    452                          
    453                         # Bluetooth module doesn't compile properly under Windows 
    454                         # and doesn't exist under OS X 
    455                          
    456                         # PyBluez API Documentation 
    457                         # http://pybluez.googlecode.com/svn/www/docs-0.7/index.html 
    458                          
    459                         bluetooth_devices = [] 
    460                          
    461                         if not enable_hcitool: 
    462                                  
    463                                 try: 
    464                                          
    465                                         if self.DEBUG: 
    466                                                 print "INFO: Searching for Bluetooth devices using PyBluez module" 
    467                                          
    468                                         bluetooth_devices = bluetooth.discover_devices( \ 
    469                                               duration=configuration.THINKGEAR_BLUETOOTH_DISCOVER_DEVICES_TIMEOUT, \ 
    470                                                                flush_cache=True, \ 
    471                                                                lookup_names=False) 
    472                                          
    473                                         for address in bluetooth_devices: 
     189                #path = 'HARDWARE\\DEVICEMAP\\SERIALCOMM' 
     190                #try: 
     191                        #key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path) 
     192                #except WindowsError: 
     193                        ##raise IterationError 
     194                        #return 
     195                 
     196                #for i in itertools.count(): 
     197                        #try: 
     198                                #val = winreg.EnumValue(key, i) 
     199                                #yield str(val[1]) 
     200                        #except EnvironmentError: 
     201                                #break 
     202         
     203         
     204        ################################################################## 
     205         
     206        #def fullPortName(self, portname): 
     207                 
     208                #""" Given a port-name (of the form COM7, 
     209                #COM12, CNCA0, etc.) returns a full 
     210                #name suitable for opening with the 
     211                #Serial class. 
     212                #""" 
     213                 
     214                #m = re.match('^COM(\d+)$', portname) 
     215                #if m and int(m.group(1)) < 10: 
     216                        #return portname 
     217                 
     218                #return '\\\\.\\' + portname 
     219         
     220         
     221        ################################################################## 
     222         
     223        #def searchForSerialDevices(self, devices=[]): 
     224                 
     225                #if (sys.platform == 'win32'): 
     226                         
     227                        #for portname in self.enumerateSerialPorts(): 
     228                                 
     229                                #if portname not in devices: 
     230                                        ##portname = self.fullPortName(portname) 
     231                                        #devices.append(portname) 
     232                 
     233                #else: 
     234                         
     235                         
     236                        #if os.path.exists('/dev/tty.MindWaveMobile-SPPDev'): 
     237                                #devices.append('/dev/tty.MindWaveMobile-SPPDev') 
     238                         
     239                        #if os.path.exists('/dev/tty.MindWave'): 
     240                                #devices.append('/dev/tty.MindWave') 
     241                        #if os.path.exists('/dev/tty.MindWave1'): 
     242                                #devices.append('/dev/tty.MindWave1') 
     243                        #if os.path.exists('/dev/tty.MindWave2'): 
     244                                #devices.append('/dev/tty.MindWave2') 
     245                        #if os.path.exists('/dev/tty.MindWave3'): 
     246                                #devices.append('/dev/tty.MindWave3') 
     247                        #if os.path.exists('/dev/tty.MindWave4'): 
     248                                #devices.append('/dev/tty.MindWave4') 
     249                        #if os.path.exists('/dev/tty.MindWave5'): 
     250                                #devices.append('/dev/tty.MindWave5') 
     251                         
     252                        #if os.path.exists('/dev/tty.MindSet-DevB'): 
     253                                #devices.append('/dev/tty.MindSet-DevB') 
     254                         
     255                        #if os.path.exists('/dev/ttyUSB0'): 
     256                                #devices.append('/dev/ttyUSB0') 
     257                        #if os.path.exists('/dev/ttyUSB1'): 
     258                                #devices.append('/dev/ttyUSB1') 
     259                        #if os.path.exists('/dev/ttyUSB2'): 
     260                                #devices.append('/dev/ttyUSB2') 
     261                        #if os.path.exists('/dev/ttyUSB3'): 
     262                                #devices.append('/dev/ttyUSB3') 
     263                        #if os.path.exists('/dev/ttyUSB4'): 
     264                                #devices.append('/dev/ttyUSB4') 
     265                        #if os.path.exists('/dev/ttyUSB5'): 
     266                                #devices.append('/dev/ttyUSB5') 
     267                        #if os.path.exists('/dev/ttyUSB6'): 
     268                                #devices.append('/dev/ttyUSB6') 
     269                        #if os.path.exists('/dev/ttyUSB7'): 
     270                                #devices.append('/dev/ttyUSB7') 
     271                        #if os.path.exists('/dev/ttyUSB8'): 
     272                                #devices.append('/dev/ttyUSB8') 
     273                        #if os.path.exists('/dev/ttyUSB9'): 
     274                                #devices.append('/dev/ttyUSB9') 
     275                         
     276                        #if os.path.exists('/dev/rfcomm0'): 
     277                                #devices.append('/dev/rfcomm0') 
     278                        #if os.path.exists('/dev/rfcomm1'): 
     279                                #devices.append('/dev/rfcomm1') 
     280                        #if os.path.exists('/dev/rfcomm2'): 
     281                                #devices.append('/dev/rfcomm2') 
     282                        #if os.path.exists('/dev/rfcomm3'): 
     283                                #devices.append('/dev/rfcomm3') 
     284                        #if os.path.exists('/dev/rfcomm4'): 
     285                                #devices.append('/dev/rfcomm4') 
     286                         
     287                        #if os.path.exists('/dev/ttyACM0'): 
     288                                #devices.append('/dev/ttyACM0') 
     289                        #if os.path.exists('/dev/ttyACM1'): 
     290                                #devices.append('/dev/ttyACM1') 
     291                        #if os.path.exists('/dev/ttyACM2'): 
     292                                #devices.append('/dev/ttyACM2') 
     293                        #if os.path.exists('/dev/ttyACM3'): 
     294                                #devices.append('/dev/ttyACM3') 
     295                        #if os.path.exists('/dev/ttyACM4'): 
     296                                #devices.append('/dev/ttyACM4') 
     297                 
     298                 
     299                #return(devices) 
     300         
     301         
     302        ################################################################## 
     303         
     304        #def hcitoolScanForRemoteDevices(self, devices=[]): 
     305                 
     306                #bluetooth_devices = [] 
     307                 
     308                ##command = '%s scan 2> /dev/null' % PATH_TO_HCITOOL 
     309                #command = '%s scan' % PATH_TO_HCITOOL 
     310                 
     311                #if self.DEBUG > 1: 
     312                        #print 'INFO: Calling "%s"' % command  
     313                 
     314                #output = os.popen(command, 'r') 
     315                 
     316                #try: 
     317                        #result = output.readlines() 
     318                #except Exception, e: 
     319                        #if self.DEBUG: 
     320                                #print "ERROR [Synapse-Interface]: Failed reading result from call to hcitool:", 
     321                                #print e 
     322                        #result = '' 
     323                 
     324                #if result == '': 
     325                        #return([]) # Under OS X hcitool doesn't exist so we don't see any devices 
     326                 
     327                #for line in result: 
     328                        #line = line.strip() 
     329                        #if line == '' or line == 'Scanning ...': 
     330                                #continue 
     331                        #elif self.DEBUG > 1: 
     332                                #print line 
     333                        #try: 
     334                                #address = line.split('\t')[0] 
     335                        #except: 
     336                                #pass 
     337                        #else: 
     338                                #bluetooth_devices.append(address) 
     339                 
     340                 
     341                #for address in bluetooth_devices: 
     342                         
     343                        #command = '%s name %s' % (PATH_TO_HCITOOL, address) 
     344                         
     345                        #if self.DEBUG: 
     346                                #print 'INFO: Calling "%s"' % command 
     347                         
     348                        #output = os.popen(command, 'r') 
     349                         
     350                        #for line in output.readlines(): 
     351                                #line = line.strip() 
     352                                #if line == '': 
     353                                        #continue 
     354                                #elif self.DEBUG: 
     355                                        #print '\t', 
     356                                        #print line 
     357                                 
     358                                #device_name = line.strip() 
     359                         
     360                                #if ((device_name == 'MindSet' or device_name == 'MindWave Mobile') and \ 
     361                                        #(address not in devices)): 
     362                                        #devices.append(address) 
     363                                 
     364                                #else: 
     365                                        #if self.DEBUG: 
     366                                                #print 'INFO: Found but not recognized: [%s] %s' % \ 
     367                                                        #(address, device_name) 
     368                 
     369                 
     370                #return (devices) 
     371         
     372         
     373        ################################################################## 
     374         
     375        #def hcitoolGetActiveConnections(self, devices=[]): 
     376                 
     377                #bluetooth_devices = [] 
     378                 
     379                ##command = '%s con 2> /dev/null' % PATH_TO_HCITOOL 
     380                #command = '%s con' % PATH_TO_HCITOOL 
     381                 
     382                #if self.DEBUG > 1: 
     383                        #print 'INFO: Calling "%s"' % command  
     384                 
     385                #output = os.popen(command, 'r') 
     386                 
     387                #try: 
     388                        #result = output.readlines() 
     389                #except Exception, e: 
     390                        #if self.DEBUG: 
     391                                #print "ERROR [Synapse:Interface]: Failed reading result from call to hcitool:", 
     392                                #print e 
     393                        #result = '' 
     394 
     395                #if result == '': 
     396                        #return([]) # Under OS X hcitool doesn't exist so we don't see any devices 
     397 
     398                #for line in result: 
     399                        #line = line.strip() 
     400                        #if line == '' or line == 'Connections:': 
     401                                #continue 
     402                        #elif self.DEBUG > 1: 
     403                                #print line 
     404                        #try: 
     405                                #address = line.split(' ')[2] 
     406                        #except: 
     407                                #pass 
     408                        #else: 
     409                                #bluetooth_devices.append(address) 
     410                 
     411                 
     412                #for address in bluetooth_devices: 
     413                         
     414                        #command = '%s name %s' % (PATH_TO_HCITOOL, address) 
     415                         
     416                        #if self.DEBUG: 
     417                                #print 'INFO: Calling "%s":' % command 
     418                         
     419                        #output = os.popen(command, 'r') 
     420                         
     421                        #for line in output.readlines(): 
     422                                #line = line.strip() 
     423                                #if line == '': 
     424                                        #continue 
     425                                #elif self.DEBUG: 
     426                                        #print '\t', 
     427                                        #print line 
     428                                 
     429                                #device_name = line.strip() 
     430                         
     431                                #if ((device_name == 'MindSet' or device_name == 'MindWave Mobile') and \ 
     432                                        #(address not in devices)): 
     433                                        #devices.append(address) 
     434                 
     435                 
     436                #return (devices) 
     437         
     438         
     439        ################################################################## 
     440         
     441        #def searchForDevices(self): 
     442                 
     443                #enable_hcitool = configuration.ENABLE_HCITOOL 
     444                 
     445                #devices = [] 
     446                 
     447                ##self.pushButtonBluetoothSearch.setText('Searching') 
     448                 
     449                #if ((sys.platform != 'win32' and sys.platform != 'darwin') and \ 
     450                     #configuration.THINKGEAR_BLUETOOTH_SEARCH): 
     451                         
     452                        ## Bluetooth module doesn't compile properly under Windows 
     453                        ## and doesn't exist under OS X 
     454                         
     455                        ## PyBluez API Documentation 
     456                        ## http://pybluez.googlecode.com/svn/www/docs-0.7/index.html 
     457                         
     458                        #bluetooth_devices = [] 
     459                         
     460                        #if not enable_hcitool: 
     461                                 
     462                                #try: 
     463                                         
     464                                        #if self.DEBUG: 
     465                                                #print "INFO: Searching for Bluetooth devices using PyBluez module" 
     466                                         
     467                                        #bluetooth_devices = bluetooth.discover_devices( \ 
     468                                              #duration=configuration.THINKGEAR_BLUETOOTH_DISCOVER_DEVICES_TIMEOUT, \ 
     469                                                               #flush_cache=True, \ 
     470                                                               #lookup_names=False) 
     471                                         
     472                                        #for address in bluetooth_devices: 
    474473                                                 
    475                                                 if self.DEBUG: 
    476                                                         print "INFO: Device discovered", 
    477                                                         print address 
     474                                                #if self.DEBUG: 
     475                                                        #print "INFO: Device discovered", 
     476                                                        #print address 
    478477                                                 
    479                                                 device_name = bluetooth.lookup_name(address, \ 
    480                                                                  configuration.THINKGEAR_BLUETOOTH_LOOKUP_NAME_TIMEOUT) 
    481                                                 if ((device_name == 'MindSet' or device_name == 'MindWave Mobile') and \ 
    482                                                         (address not in devices)): 
    483                                                         devices.append(address) 
    484                                          
    485                                          
    486                                         # There is an issue under recent released of Linux 
    487                                         # in which already-connected Bluetooth ThinkGear devices 
    488                                         # are not appearing in a bluetooth device scan. However, 
    489                                         # using "hcitool" connected devices can be listed correctly. 
    490                                         # There does not appear to be an equivalent PyBluez feature. 
    491                                         # (http://pybluez.googlecode.com/svn/www/docs-0.7/index.html) 
    492                                          
    493                                         if devices == []: 
    494                                                 if self.DEBUG: 
    495                                                         print "INFO: No devices found through PyBluez module. Falling back to hcitool." 
    496                                                 devices = self.hcitoolGetActiveConnections(devices) 
    497                                  
    498                                  
    499                                 except Exception, e: 
    500                                         if self.DEBUG: 
    501                                                 print "ERROR: Exception calling Python Bluetooth module. (Is PyBluez installed?):" 
    502                                                 print e 
    503                                          
    504                                          
    505                                         #if (sys.platform != 'darwin'): 
    506                                         enable_hcitool = True 
    507                          
    508                          
    509                         if enable_hcitool: 
    510                                  
    511                                 devices = self.hcitoolScanForRemoteDevices(devices) 
    512                                 devices = self.hcitoolGetActiveConnections(devices) 
    513                          
    514                          
    515                         if self.DEBUG > 2: 
    516                                 print "Bluetooth Devices found:", 
    517                                 print devices 
    518                  
    519                  
    520                 devices = self.searchForSerialDevices(devices) 
    521                  
    522                  
    523                 if self.DEBUG: 
    524                         print "Devices found:", 
    525                         print devices 
    526                  
    527                  
    528                 return(devices) 
     478                                                #device_name = bluetooth.lookup_name(address, \ 
     479                                                                 #configuration.THINKGEAR_BLUETOOTH_LOOKUP_NAME_TIMEOUT) 
     480                                                #if ((device_name == 'MindSet' or device_name == 'MindWave Mobile') and \ 
     481                                                        #(address not in devices)): 
     482                                                        #devices.append(address) 
     483                                         
     484                                         
     485                                        ## There is an issue under recent released of Linux 
     486                                        ## in which already-connected Bluetooth ThinkGear devices 
     487                                        ## are not appearing in a bluetooth device scan. However, 
     488                                        ## using "hcitool" connected devices can be listed correctly. 
     489                                        ## There does not appear to be an equivalent PyBluez feature. 
     490                                        ## (http://pybluez.googlecode.com/svn/www/docs-0.7/index.html) 
     491                                         
     492                                        #if devices == []: 
     493                                                #if self.DEBUG: 
     494                                                        #print "INFO: No devices found through PyBluez module. Falling back to hcitool." 
     495                                                #devices = self.hcitoolGetActiveConnections(devices) 
     496                                 
     497                                 
     498                                #except Exception, e: 
     499                                        #if self.DEBUG: 
     500                                                #print "ERROR: Exception calling Python Bluetooth module. (Is PyBluez installed?):" 
     501                                                #print e 
     502                                         
     503                                         
     504                                        ##if (sys.platform != 'darwin'): 
     505                                        #enable_hcitool = True 
     506                         
     507                         
     508                        #if enable_hcitool: 
     509                                 
     510                                #devices = self.hcitoolScanForRemoteDevices(devices) 
     511                                #devices = self.hcitoolGetActiveConnections(devices) 
     512                         
     513                         
     514                        #if self.DEBUG > 2: 
     515                                #print "Bluetooth Devices found:", 
     516                                #print devices 
     517                 
     518                 
     519                #devices = self.searchForSerialDevices(devices) 
     520                 
     521                 
     522                #if self.DEBUG: 
     523                        #print "Devices found:", 
     524                        #print devices 
     525                 
     526                 
     527                #return(devices) 
    529528         
    530529         
Note: See TracChangeset for help on using the changeset viewer.