Changeset 163


Ignore:
Timestamp:
08/19/10 12:59:28 (11 years ago)
Author:
sc
Message:
  • Merge of code from repackaging by John Schutte <g.john.schutte@…>
Location:
trunk/synapse
Files:
10 added
1 edited
6 moved

Legend:

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

    r161 r163  
    1 #!/usr/bin/env python 
    21# -*- coding: utf-8 -*- 
    3 # 
    4 # Puzzlebox - Synapse -Client - Thinkgear 
    5 # 
     2 
    63# Copyright Puzzlebox Productions, LLC (2010) 
    74# 
    85# This code is released under the GNU Pulic License (GPL) version 2 
    96# For more information please refer to http://www.gnu.org/copyleft/gpl.html 
    10 # 
    11 # Last Update: 2010.08.09 
    12 # 
    13 ##################################################################### 
     7 
     8# Old Class Names: 
     9#       puzzlebox_synapse_client_thinkgear = QtClient 
     10#       puzzlebox_synapse_client_thinkgear_command_line = CLIClient 
     11 
     12__changelog__ = """\ 
     13Last Update: 2010.08.09 
     14 
     15""" 
    1416 
    1517import os, sys 
     
    2628 
    2729from PyQt4 import QtNetwork 
    28  
    2930import simplejson as json 
    30  
    31 import puzzlebox_synapse_configuration as configuration 
     31import Configuration as configuration 
    3232#import puzzlebox_logger 
    3333 
     
    5454##################################################################### 
    5555 
    56 class puzzlebox_synapse_client_thinkgear(QtCore.QThread): 
     56class QtClient(QtCore.QThread): 
    5757         
    5858        def __init__(self, log, \ 
     
    8484                self.socket.name = 'ThinkGear Client' 
    8585                 
    86                 if self.server_host == '*': 
    87                         self.server_host = '127.0.0.1' 
    88  
    89                 self.server_host=QtNetwork.QHostAddress(self.server_host) 
     86                if ((self.server_host == '') or \ 
     87                         (self.server_host == '*')): 
     88                        self.server_host=QtNetwork.QHostAddress.Any 
    9089                 
    9190                self.socket.readyRead.connect(self.printReply) 
     
    230229##################################################################### 
    231230 
    232 class puzzlebox_synapse_client_thinkgear_command_line( \ 
    233               puzzlebox_synapse_client_thinkgear): 
     231class CLIClient(QtClient): 
    234232         
    235233        def __init__(self, log, \ 
     
    276274                 
    277275                return(command) 
    278  
    279  
    280 ##################################################################### 
    281 # Main 
    282 ##################################################################### 
    283  
    284 if __name__ == '__main__': 
    285          
    286         # Perform correct KeyboardInterrupt handling 
    287         signal.signal(signal.SIGINT, signal.SIG_DFL) 
    288          
    289         #log = puzzlebox_logger.puzzlebox_logger(logfile='client_thinkgear') 
    290         log = None 
    291          
    292         command_parameters = sys.argv[1:] 
    293          
    294         #log.info("Command parameters: %s" % command_parameters) 
    295          
    296         app = QtCore.QCoreApplication(sys.argv) 
    297          
    298         client = puzzlebox_synapse_client_thinkgear_command_line(log, \ 
    299                     command_parameters, \ 
    300                     server_host=SERVER_HOST, \ 
    301                     server_port=SERVER_PORT, \ 
    302                     DEBUG=DEBUG) 
    303          
    304         #while True: 
    305                 #while client.socket.waitForReadyRead(CLIENT_NO_REPLY_WAIT): 
    306                         #pass 
    307          
    308         sys.exit(app.exec_()) 
    309  
  • trunk/synapse/Puzzlebox/Synapse/Configuration.py

    r161 r163  
    11#!/usr/bin/env python 
    22# -*- coding: utf-8 -*- 
    3 # 
    4 # Puzzlebox - Synapse - Configuration 
    5 # 
     3 
    64# Copyright Puzzlebox Productions, LLC (2010) 
    75# 
    86# This code is released under the GNU Pulic License (GPL) version 2 
    97# For more information please refer to http://www.gnu.org/copyleft/gpl.html 
    10 # 
    11 # Last Update: 2010.08.12 
    12 # 
    13 ##################################################################### 
     8 
     9__changelog__ = """\ 
     10Last Update: 2010.08.09 
     11 
     12""" 
    1413 
    1514import os, sys 
  • trunk/synapse/Puzzlebox/Synapse/Interface.py

    r161 r163  
    1 #!/usr/bin/env python 
    21# -*- coding: utf-8 -*- 
    3 # 
    4 # Puzzlebox - Synapse - Interface 
    5 # 
     2 
    63# Copyright Puzzlebox Productions, LLC (2010) 
    74# 
    85# This code is released under the GNU Pulic License (GPL) version 2 
    96# For more information please refer to http://www.gnu.org/copyleft/gpl.html 
    10 # 
    11 # Last Update: 2010.08.12 
    12 # 
    13 ##################################################################### 
    14 # To Do: 
    15 # - update configuration.ini file with settings entered into interface 
    16 ##################################################################### 
    17  
     7 
     8# Old Class Names: 
     9#       puzzlebox_synapse_interface = QtUI 
     10#       design.Ui_Form = Design 
     11 
     12__changelog__ = """\ 
     13Last Update: 2010.08.09 
     14 
     15""" 
     16 
     17__todo__ = """ 
     18 - update configuration.ini file with settings entered into interface 
     19 
     20""" 
     21 
     22### IMPORTS ### 
    1823import os, sys 
    19  
    2024import simplejson as json 
    2125 
     
    2529else: 
    2630        import serial 
    27         import re 
    28         import _winreg as winreg 
    29         import itertools 
    3031        DEFAULT_IMAGE_PATH = 'images' 
    3132 
     
    3940        print "Using PySide module" 
    4041 
    41 #from PyQt4 import QtCore, QtGui 
    42 #from PySide import QtCore, QtGui 
    43  
    44 from puzzlebox_synapse_interface_design import Ui_Form 
    45  
    46 import puzzlebox_synapse_configuration as configuration 
    47 import puzzlebox_synapse_server_thinkgear as synapse_server 
    48 import puzzlebox_synapse_client_thinkgear as thinkgear_client 
     42# from puzzlebox_synapse_interface_design import Ui_Form 
     43from Interface_Design import Ui_Form as Design 
     44 
     45import Configuration as configuration 
     46import Server as synapse_server 
     47import Client as thinkgear_client 
    4948#import puzzlebox_logger 
    5049 
    51 ##################################################################### 
    52 # Globals 
    53 ##################################################################### 
     50### GLOBALS ### 
    5451 
    5552DEBUG = 1 
     
    7471INTERFACE_UPDATE_FREQUENCY = 1000 # ms 
    7572 
    76 ##################################################################### 
    77 # Classes 
    78 ##################################################################### 
    79  
    80 class puzzlebox_synapse_interface(QtGui.QWidget, Ui_Form): 
     73### CLASSES ### 
     74 
     75class QtUI(QtGui.QWidget, Design): 
    8176         
    8277        def __init__(self, log, server=None, DEBUG=DEBUG, parent = None): 
     
    242237                # and re-connects to a MindSet Emulator, 
    243238                # we need to reset the max power values 
    244                 self.progressBarEEGDelta.setMaximum(self.maxEEGPower) 
    245                 self.progressBarEEGTheta.setMaximum(self.maxEEGPower) 
    246                 self.progressBarEEGLowAlpha.setMaximum(self.maxEEGPower) 
    247                 self.progressBarEEGHighAlpha.setMaximum(self.maxEEGPower) 
    248                 self.progressBarEEGLowBeta.setMaximum(self.maxEEGPower) 
    249                 self.progressBarEEGHighBeta.setMaximum(self.maxEEGPower) 
    250                 self.progressBarEEGLowGamma.setMaximum(self.maxEEGPower) 
    251                 self.progressBarEEGMidGamma.setMaximum(self.maxEEGPower) 
     239                self.progressBarEEGDelta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
     240                self.progressBarEEGTheta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
     241                self.progressBarEEGLowAlpha.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
     242                self.progressBarEEGHighAlpha.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
     243                self.progressBarEEGLowBeta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
     244                self.progressBarEEGHighBeta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
     245                self.progressBarEEGLowGamma.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
     246                self.progressBarEEGMidGamma.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
    252247         
    253248         
     
    272267                 
    273268                self.thinkGearConnectServer = \ 
    274                         synapse_server.puzzlebox_synapse_server_thinkgear( \ 
    275                                 log, \ 
     269                        synapse_server.ThinkgearServer( \ 
     270                                self.log, \ 
    276271                                server_interface=server_interface, \ 
    277272                                server_port=server_port, \ 
     
    289284                else: 
    290285                        self.thinkgearConnectClient = \ 
    291                                 thinkgear_client.puzzlebox_synapse_client_thinkgear( \ 
     286                                thinkgear_client.QtClient( \ 
    292287                                        self.log, \ 
    293288                                        server_host=server_interface, \ 
     
    381376                if ('eegPower' in packet.keys()): 
    382377                         
    383                         # If we are not emulating packets we'll set the maximum EEG Power value 
    384                         # threshold to the default (or maximum value found within this packet) 
    385                         if not self.thinkGearConnectServer.emulate_headset_data: 
    386                                 self.maxEEGPower = THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE 
    387378                         
    388379                        for value in packet['eegPower'].keys(): 
     
    441432         
    442433        ################################################################## 
    443  
    444         def enumerateSerialPorts(self): 
    445                  
    446                 """ Uses the Win32 registry to return an 
    447                 iterator of serial (COM) ports 
    448                 existing on this computer. 
    449  
    450                 from http://eli.thegreenplace.net/2009/07/31/listing-all-serial-ports-on-windows-with-python/ 
    451                 """ 
    452              
    453                 path = 'HARDWARE\\DEVICEMAP\\SERIALCOMM' 
    454                 try: 
    455                         key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path) 
    456                 except WindowsError: 
    457                         raise IterationError 
    458  
    459                 for i in itertools.count(): 
    460                         try: 
    461                                 val = winreg.EnumValue(key, i) 
    462                                 yield str(val[1]) 
    463                         except EnvironmentError: 
    464                                 break 
    465  
    466  
    467         ################################################################## 
    468                          
    469         def fullPortName(self, portname): 
    470                  
    471                 """ Given a port-name (of the form COM7, 
    472                 COM12, CNCA0, etc.) returns a full 
    473                 name suitable for opening with the 
    474                 Serial class. 
    475                 """ 
    476  
    477                 m = re.match('^COM(\d+)$', portname) 
    478                 if m and int(m.group(1)) < 10: 
    479                         return portname 
    480                  
    481                 return '\\\\.\\' + portname 
    482  
    483          
    484         ################################################################## 
    485434         
    486435        def searchForThinkGearDevices(self): 
    487436                 
    488437                #self.pushButtonBluetoothSearch.setText('Searching') 
    489  
    490                 mindset_devices = [] 
    491                  
    492                 if (sys.platform == 'win32'): 
    493  
    494                         for portname in self.enumerateSerialPorts(): 
    495  
    496                                 #portname = self.fullPortName(portname) 
    497                                 mindset_devices.append(portname) 
    498  
    499  
    500                 else: 
     438                 
     439                if (sys.platform != 'win32'): 
    501440                         
    502441                        # Bluetooth module doesn't compile properly under Windows 
     
    508447                                                    #flush_cache=True, \ 
    509448                                                    #lookup_names=True) 
     449                         
     450                        addresses = [] 
    510451                         
    511452                        command = '%s con' % PATH_TO_HCITOOL 
     
    519460                                        pass 
    520461                                else: 
    521                                         bluetooth_devices.append(address) 
    522                          
    523                         for address in bluetooth_devices: 
     462                                        addresses.append(address) 
     463                         
     464                        for address in addresses: 
    524465                                device_name = bluetooth.lookup_name(address) 
    525466                                if device_name == 'MindSet': 
    526                                         mindset_devices.append(address) 
     467                                        bluetooth_devices.append(address) 
    527468                         
    528469                         
    529470                        if self.DEBUG: 
    530                                 print "Bluetooth MindSet devices found:", 
    531                                 print mindset_devices 
     471                                print "Bluetooth devices found:", 
     472                                print bluetooth_devices 
    532473                         
    533474                         
     
    537478                         
    538479                         
    539                 for mindset_device in mindset_devices: 
    540                         self.comboBoxDeviceSelect.addItem(mindset_device) 
     480                        for mindset_device in bluetooth_devices: 
     481                                self.comboBoxDeviceSelect.addItem(mindset_device) 
    541482                 
    542483                 
     
    573514                        event.ignore() 
    574515 
    575  
    576 ##################################################################### 
    577 # Functions 
    578 ##################################################################### 
    579  
    580 ##################################################################### 
    581 # Main 
    582 ##################################################################### 
    583  
    584 if __name__ == '__main__': 
    585          
    586         #log = puzzlebox_logger.puzzlebox_logger(logfile='client_interface') 
    587         log = None 
    588          
    589         app = QtGui.QApplication(sys.argv) 
    590          
    591         window = puzzlebox_synapse_interface(log, DEBUG) 
    592         window.show() 
    593          
    594         sys.exit(app.exec_()) 
    595  
  • trunk/synapse/Puzzlebox/Synapse/Protocol.py

    r161 r163  
    1 #!/usr/bin/env python 
    21# -*- coding: utf-8 -*- 
    3 # 
    4 # Puzzlebox - Synapse - Protocol - ThinkGear - Serial 
    5 # 
     2 
    63# Copyright Puzzlebox Productions, LLC (2010) 
    74# 
    85# This code is released under the GNU Pulic License (GPL) version 2 
    96# For more information please refer to http://www.gnu.org/copyleft/gpl.html 
    10 # 
    11 # Last Update: 2010.08.12 
    12 # 
    13 ##################################################################### 
    14 # SPEC: 
    15 # 
    16 # CODE Definitions Table 
    17 # Single-Byte CODEs 
    18 # Extended             (Byte) 
    19 # Code Level   [CODE] [LENGTH] Data Value Meaning 
    20 # ----------   ------ -------- ------------------ 
    21 #           0    0x02        - POOR_SIGNAL Quality (0-255) 
    22 #           0    0x04        - ATTENTION eSense (0 to 100) 
    23 #           0    0x05        - MEDITATION eSense (0 to 100) 
    24 #           0    0x16        - Blink Strength. (0-255) Sent only 
    25 #                              when Blink event occurs. 
    26 # Multi-Byte CODEs 
    27 # Extended             (Byte) 
    28 # Code Level   [CODE] [LENGTH] Data Value Meaning 
    29 # ----------   ------ -------- ------------------ 
    30 #           0    0x80        2 RAW Wave Value: a single big-endian 
    31 #                                16-bit two's-compliment signed value 
    32 #                                (high-order byte followed by 
    33 #                                low-order byte) (-32768 to 32767) 
    34 #           0    0x83       24 ASIC_EEG_POWER: eight big-endian 
    35 #                                3-byte unsigned integer values 
    36 #                                representing delta, theta, low-alpha 
    37 #                                high-alpha, low-beta, high-beta, 
    38 #                                low-gamma, and mid-gamma EEG band 
    39 #                                power values 
    40 #         Any    0x55        - NEVER USED (reserved for [EXCODE]) 
    41 #         Any    0xAA        - NEVER USED (reserved for [SYNC]) 
    42 # 
    43 ##################################################################### 
    44 # Linux Bluetooth serial protocol profile example: 
    45 #    rfcomm connect rfcomm0 00:13:EF:00:1B:FE 3 
    46 ##################################################################### 
    47 # TODO: 
    48 # - needs to handle: 
    49 #   serial.serialutil.SerialException:  
    50 #   could not open port /dev/rfcomm0:  
    51 #   [Errno 16] Device or resource busy: '/dev/rfcomm0' 
    52 ##################################################################### 
    53  
     7 
     8# Old Classes: 
     9#       puzzlebox_synapse_protocol_thinkgear = ProtocolHandler 
     10#       puzzlebox_synapse_protocol_thinkgear_serial_device = SerialDevice 
     11 
     12__changelog__ = """\ 
     13Last Update: 2010.08.19 
     14 
     15""" 
     16 
     17__doc__ = """\ 
     18Puzzlebox.Synapse.Protocol 
     19 
     20usage: 
     21  from Puzzlebox.Synapse import Protocol 
     22 
     23Modules: 
     24  Protocol.ProtocolHandler() 
     25  Protocol.SerialDevice() 
     26 
     27SPEC: 
     28 
     29 CODE Definitions Table 
     30 Single-Byte CODEs 
     31 Extended             (Byte) 
     32 Code Level   [CODE] [LENGTH] Data Value Meaning 
     33 ----------   ------ -------- ------------------ 
     34           0    0x02        - POOR_SIGNAL Quality (0-255) 
     35           0    0x04        - ATTENTION eSense (0 to 100) 
     36           0    0x05        - MEDITATION eSense (0 to 100) 
     37           0    0x16        - Blink Strength. (0-255) Sent only 
     38                              when Blink event occurs. 
     39 Multi-Byte CODEs 
     40 Extended             (Byte) 
     41 Code Level   [CODE] [LENGTH] Data Value Meaning 
     42 ----------   ------ -------- ------------------ 
     43           0    0x80        2 RAW Wave Value: a single big-endian 
     44                                16-bit two's-compliment signed value 
     45                                (high-order byte followed by 
     46                                low-order byte) (-32768 to 32767) 
     47           0    0x83       24 ASIC_EEG_POWER: eight big-endian 
     48                                3-byte unsigned integer values 
     49                                representing delta, theta, low-alpha 
     50                                high-alpha, low-beta, high-beta, 
     51                                low-gamma, and mid-gamma EEG band 
     52                                power values 
     53         Any    0x55        - NEVER USED (reserved for [EXCODE]) 
     54         Any    0xAA        - NEVER USED (reserved for [SYNC]) 
     55 
     56 
     57Linux Bluetooth serial protocol profile example: 
     58    rfcomm connect rfcomm0 00:13:EF:00:1B:FE 3 
     59 
     60TODO: 
     61 - needs to handle: 
     62   serial.serialutil.SerialException:  
     63   could not open port /dev/rfcomm0:  
     64   [Errno 16] Device or resource busy: '/dev/rfcomm0' 
     65 
     66""" 
     67 
     68### IMPORTS ### 
    5469import sys 
    5570import signal 
    56  
    5771import serial 
    5872 
     
    6983        print "Using PySide module" 
    7084 
    71 #from PyQt4 import QtCore 
    72 #from PySide import QtCore 
    73  
    74 import puzzlebox_synapse_configuration as configuration 
    75 #import puzzlebox_logger 
    76  
    77 ##################################################################### 
    78 # Globals 
    79 ##################################################################### 
     85import Configuration as configuration 
     86 
     87### GLOBALS ### 
    8088 
    8189DEBUG = 2 
     
    111119DEBUG_PACKET_COUNT = 1024 
    112120 
    113 ##################################################################### 
    114 # Classes 
    115 ##################################################################### 
    116  
    117 class serialWrapper(serial.Serial): 
    118  
    119         #__init__(port=None, baudrate=9600, bytesize=EIGHTBITS, parity=PARITY_NONE, stopbits=STOPBITS_ONE, timeout=None, xonxoff=False, rtscts=False, writeTimeout=None, dsrdtr=False, interCharTimeout=None) 
    120  
    121         def recv(self, size=1): 
    122  
    123                 return(self.read(size)) 
    124  
    125  
    126 ##################################################################### 
    127 ##################################################################### 
    128  
    129 class puzzlebox_synapse_protocol_thinkgear(QtCore.QThread): 
     121### CLASSES ### 
     122 
     123class ProtocolHandler(QtCore.QThread): 
    130124         
    131125        def __init__(self, log, \ 
     
    365359                 
    366360                for key in eegPower.keys(): 
    367                         #eegPower[key] = self.hexStringEndianSwap(eegPower[key]) 
     361                        eegPower[key] = self.hexStringEndianSwap(eegPower[key]) 
    368362                        #eegPower[key] = eegPower[key].encode("hex") 
    369363                        eegPower[key] = int(eegPower[key], 16) 
     
    722716 
    723717 
    724 ##################################################################### 
    725 ##################################################################### 
    726  
    727 class puzzlebox_synapse_protocol_thinkgear_serial_device(QtCore.QThread): 
     718 
     719class SerialDevice(QtCore.QThread): 
    728720         
    729721        def __init__(self, log, \ 
     
    833825                else: 
    834826                        init_rts_cts_flow_control = 0 
    835  
    836                 print self.device_address 
     827                 
    837828                 
    838829                try: 
    839 ##                      device = serial.Serial(port = self.device_address, \ 
    840 ##                                                  baudrate = baudrate, \ 
    841 ##                                                  bytesize = init_byte_size, \ 
    842 ##                                                  parity = init_parity, \ 
    843 ##                                                  stopbits = init_stopbits, \ 
    844 ##                                                  xonxoff = init_software_flow_control, \ 
    845 ##                                                  rtscts = init_rts_cts_flow_control, \ 
    846 ##                                                  timeout = timeout) 
    847  
    848                         device = serialWrapper(port = self.device_address, \ 
     830                        device = serial.Serial(port = self.device_address, \ 
    849831                                                    baudrate = baudrate, \ 
    850832                                                    bytesize = init_byte_size, \ 
     
    858840                        if self.DEBUG: 
    859841                                print "ERROR:", 
    860                                 print e, 
    861                                 print self.device_address 
     842                                print e 
    862843                                sys.exit() 
    863844                 
     
    963944                 
    964945                self.exitThread() 
    965  
    966  
    967 ##################################################################### 
    968 # Functions 
    969 ##################################################################### 
    970  
    971 def exitHandler(signal, frame): 
    972          
    973         if DEBUG: 
    974                 print "exitHandler: Interrupt signal caught" 
    975          
    976         serial_device.exitThread(callThreadQuit=False) 
    977         protocol.exitThread(callThreadQuit=False) 
    978         sys.exit() 
    979  
    980  
    981 ##################################################################### 
    982 # Main 
    983 ##################################################################### 
    984  
    985 if __name__ == '__main__': 
    986          
    987         # Perform correct KeyboardInterrupt handling 
    988         signal.signal(signal.SIGINT, signal.SIG_DFL) 
    989         #signal.signal(signal.SIGINT, exitHandler) 
    990          
    991         #log = puzzlebox_logger.puzzlebox_logger(logfile='server_thinkgear') 
    992         log = None 
    993          
    994         # Collect default settings and command line parameters 
    995         if THINKGEAR_DEVICE_BLUETOOTH_ADDRESS == '': 
    996                 device_address = THINKGEAR_DEVICE_SERIAL_PORT 
    997         else: 
    998                 device_address = THINKGEAR_DEVICE_BLUETOOTH_ADDRESS 
    999          
    1000         for each in sys.argv: 
    1001                  
    1002                 if each.startswith("--device="): 
    1003                         device_address = each[ len("--device="): ] 
    1004          
    1005          
    1006         app = QtCore.QCoreApplication(sys.argv) 
    1007          
    1008         serial_device = puzzlebox_synapse_protocol_thinkgear_serial_device( \ 
    1009                                 log, \ 
    1010                                 device_address, \ 
    1011                                 DEBUG=DEBUG) 
    1012         #serial_device.start() 
    1013          
    1014         protocol = puzzlebox_synapse_protocol_thinkgear(log, \ 
    1015                                                              serial_device, \ 
    1016                                                              DEBUG=DEBUG) 
    1017          
    1018         protocol.start() 
    1019          
    1020         serial_device.run() 
    1021          
    1022         # We do not call app.exec_() because the serial parser executes as the main thread 
    1023         #sys.exit(app.exec_()) 
    1024  
  • trunk/synapse/Puzzlebox/Synapse/Server.py

    r161 r163  
    1 #!/usr/bin/env python 
    21# -*- coding: utf-8 -*- 
    3 # 
    4 # Puzzlebox - Synapse - Server 
    5 # 
     2 
    63# Copyright Puzzlebox Productions, LLC (2010) 
    74# 
    85# This code is released under the GNU Pulic License (GPL) version 2 
    96# For more information please refer to http://www.gnu.org/copyleft/gpl.html 
    10 # 
    11 # Last Update: 2010.08.09 
    12 # 
    13 ##################################################################### 
     7 
     8# Old Class Name = puzzle_synapse_server_thinkgear 
     9 
     10__changelog__ = """\ 
     11Last Update: 2010.08.09 
     12 
     13""" 
     14 
     15### IMPORTS ### 
    1416 
    1517import os, sys, time 
     
    3032from PyQt4 import QtNetwork 
    3133 
    32 import puzzlebox_synapse_configuration as configuration 
    33 import puzzlebox_synapse_protocol_thinkgear as serial_interface 
    34 #import puzzlebox_logger 
    35  
    36 ##################################################################### 
    37 # Globals 
    38 ##################################################################### 
     34import Configuration as configuration 
     35import Protocol as serial_interface 
     36 
     37### GLOBALS ### 
    3938 
    4039DEBUG = 1 
     
    122121DEFAULT_RESPONSE_MESSAGE = DEFAULT_SIGNAL_LEVEL_MESSAGE 
    123122 
    124 ##################################################################### 
    125 # Classes 
    126 ##################################################################### 
    127  
    128 class puzzlebox_synapse_server_thinkgear(QtCore.QThread): 
     123### CLASS MODULE ### 
     124 
     125class ThinkgearServer(QtCore.QThread): 
    129126         
    130127        def __init__(self, log, \ 
     
    180177                         
    181178                        self.serial_device = \ 
    182                                 serial_interface.puzzlebox_synapse_protocol_thinkgear_serial_device( \ 
     179                                serial_interface.SerialDevice( \ 
    183180                                        self.log, \ 
    184181                                        device_address=self.device_address, \ 
     
    189186                         
    190187                        self.protocol = \ 
    191                                 serial_interface.puzzlebox_synapse_protocol_thinkgear( \ 
     188                                serial_interface.ProtocolHandler( \ 
    192189                                        self.log, \ 
    193190                                        self.serial_device, \ 
     
    602599                if self.parent == None: 
    603600                        sys.exit() 
    604  
    605  
    606 ##################################################################### 
    607 # Functions 
    608 ##################################################################### 
    609  
    610 def exitHandler(signal, frame): 
    611          
    612         if DEBUG > 1: 
    613                 print "exitHandler: Interrupt signal caught" 
    614          
    615         server.exitThread(callThreadQuit=False) 
    616         sys.exit() 
    617  
    618  
    619 ##################################################################### 
    620 # Main 
    621 ##################################################################### 
    622  
    623 if __name__ == '__main__': 
    624          
    625         # Perform correct KeyboardInterrupt handling 
    626         signal.signal(signal.SIGINT, signal.SIG_DFL) 
    627         #signal.signal(signal.SIGINT, exitHandler) 
    628          
    629         #log = puzzlebox_logger.puzzlebox_logger(logfile='server_thinkgear') 
    630         log = None 
    631          
    632         # Collect default settings and command line parameters 
    633         server_interface = SERVER_INTERFACE 
    634         server_port = SERVER_PORT 
    635         device_address = THINKGEAR_DEVICE_SERIAL_PORT 
    636          
    637          
    638         for each in sys.argv: 
    639                  
    640                 if each.startswith("--interface="): 
    641                         server_interface = each[ len("--interface="): ] 
    642                 if each.startswith("--port="): 
    643                         server_port = each[ len("--port="): ] 
    644                 if each.startswith("--device="): 
    645                         device_address = each[ len("--device="): ] 
    646          
    647          
    648         app = QtCore.QCoreApplication(sys.argv) 
    649          
    650         server = puzzlebox_synapse_server_thinkgear( \ 
    651                          log, \ 
    652                          server_interface, \ 
    653                          server_port, \ 
    654                          device_address, \ 
    655                          emulate_headset_data = \ 
    656                             ENABLE_SIMULATE_HEADSET_DATA, \ 
    657                          DEBUG=DEBUG) 
    658          
    659         server.start() 
    660          
    661         sys.exit(app.exec_()) 
    662  
  • trunk/synapse/puzzlebox_synapse_configuration.ini

    r147 r163  
    1212 
    1313# Use Bluetooth MAC address for Linux 
    14 THINKGEAR_DEVICE_BLUETOOTH_ADDRESS = '' 
     14THINKGEAR_DEVICE_BLUETOOTH_ADDRESS = '00:13:EF:00:56:70' 
    1515# THINKGEAR_DEVICE_BLUETOOTH_ADDRESS = '00:13:EF:xx:xx:xx' # Linux example 
    1616 
Note: See TracChangeset for help on using the changeset viewer.