Ignore:
Timestamp:
07/28/10 01:43:02 (11 years ago)
Author:
sc
Message:

thinkgear_emulator/puzzlebox_thinkgear_serial_protocol.py:

  • QThread support added to prevent blocking of device stream
  • puzzlebox_thinkgear_serial_device class added
  • puzzlebox_thinkgear_serial_protocol class renamed
File:
1 edited

Legend:

Unmodified
Added
Removed
  • thinkgear_emulator/puzzlebox_thinkgear_serial_protocol.py

    r124 r125  
    99# For more information please refer to http://www.gnu.org/copyleft/gpl.html 
    1010# 
    11 # Last Update: 2010.07.22 
     11# Last Update: 2010.07.27 
    1212# 
    1313##################################################################### 
     
    5353 
    5454import sys 
     55import signal 
    5556import serial 
    5657 
    57 #from PyQt4 import QtCore, QtNetwork 
     58#try: 
     59        #import PySide as PyQt4 
     60        #from PySide import QtCore, QtGui, QtNetwork 
     61#except: 
     62        #print "Using PyQt4 module" 
     63        #from PyQt4 import QtCore, QtGui, QtNetwork 
     64#else: 
     65        #print "Using PySide module" 
     66         
     67from PyQt4 import QtCore 
     68#from PySide import QtCore, QtGui, QtNetwork 
    5869 
    5970import puzzlebox_thinkgear_emulator_configuration as configuration 
     
    8899##################################################################### 
    89100 
    90 class puzzlebox_thinkgear_serial_protocol: 
     101class puzzlebox_thinkgear_serial_protocol(QtCore.QThread): 
    91102         
    92103        def __init__(self, log, \ 
     104                               serial_device, \ 
    93105                               serial_port=DEFAULT_SERIAL_PORT, \ 
    94106                               DEBUG=DEBUG, \ 
    95107                               parent=None): 
    96108                 
     109                QtCore.QThread.__init__(self,parent) 
     110                 
    97111                self.log = log 
    98112                self.DEBUG = DEBUG 
     
    102116                self.buffer = '' 
    103117                 
    104                 self.device = self.initialize_device() 
    105          
    106          
    107         ################################################################## 
    108          
    109         def initialize_device(self): 
    110                  
    111                 baudrate = DEFAULT_SERIAL_BAUDRATE 
    112                 bytesize = 8 
    113                 parity = 'NONE' 
    114                 stopbits = 1 
    115                 software_flow_control = 'f' 
    116                 rts_cts_flow_control = 'f' 
    117                 #timeout = 15 
    118                 timeout = 5 
    119                  
    120                 # convert bytesize 
    121                 if (bytesize == 5): 
    122                         init_byte_size = serial.FIVEBITS 
    123                 elif (bytesize == 6): 
    124                         init_byte_size = serial.SIXBITS 
    125                 elif (bytesize == 7): 
    126                         init_byte_size = serial.SEVENBITS 
    127                 elif (bytesize == 8): 
    128                         init_byte_size = serial.EIGHTBITS 
    129                 else: 
    130                         #self.log.perror("Invalid value for %s modem byte size! Using default (8)" % modem_type) 
    131                         init_byte_size = serial.EIGHTBITS 
    132                  
    133                 # convert parity 
    134                 if (parity == 'NONE'): 
    135                         init_parity = serial.PARITY_NONE 
    136                 elif (parity == 'EVEN'): 
    137                         init_parity = serial.PARITY_EVEN 
    138                 elif (parity == 'ODD'): 
    139                         init_parity = serial.PARITY_ODD 
    140                 else: 
    141                         #self.log.perror("Invalid value for %s modem parity! Using default (NONE)" % modem_type) 
    142                         init_parity = serial.PARITY_NONE 
    143                  
    144                 # convert stopbits 
    145                 if (stopbits == 1): 
    146                         init_stopbits = serial.STOPBITS_ONE 
    147                 elif (stopbits == 2): 
    148                         init_stopbits = serial.STOPBITS_TWO 
    149                 else: 
    150                         #self.log.perror("Invalid value for %s modem stopbits! Using default (8)" % modem_type) 
    151                         init_byte_size = serial.STOPBITS_ONE 
    152                  
    153                 # convert software flow control 
    154                 if (software_flow_control == 't'): 
    155                         init_software_flow_control = 1 
    156                 else: 
    157                         init_software_flow_control = 0 
    158                  
    159                 # convert rts cts flow control 
    160                 if (rts_cts_flow_control == 't'): 
    161                         init_rts_cts_flow_control = 1 
    162                 else: 
    163                         init_rts_cts_flow_control = 0 
    164                  
    165                  
    166                 # Initialize the modem 
    167                 #self.log.pdebug("Initializing %s modem" % modem_code) 
    168                  
    169                 device = serial.Serial(port = serial_port, \ 
    170                                             baudrate = baudrate, \ 
    171                                             bytesize = init_byte_size, \ 
    172                                             parity = init_parity, \ 
    173                                             stopbits = init_stopbits, \ 
    174                                             xonxoff = init_software_flow_control, \ 
    175                                             rtscts = init_rts_cts_flow_control, \ 
    176                                             timeout = timeout) 
    177                  
    178                  
    179                 return(device) 
     118                #self.device = self.initialize_device() 
     119                 
     120                self.device = serial_device 
     121         
     122         
     123        ################################################################## 
     124         
     125        #def initialize_device(self): 
     126                 
     127                #baudrate = DEFAULT_SERIAL_BAUDRATE 
     128                #bytesize = 8 
     129                #parity = 'NONE' 
     130                #stopbits = 1 
     131                #software_flow_control = 'f' 
     132                #rts_cts_flow_control = 'f' 
     133                ##timeout = 15 
     134                #timeout = 5 
     135                 
     136                ## convert bytesize 
     137                #if (bytesize == 5): 
     138                        #init_byte_size = serial.FIVEBITS 
     139                #elif (bytesize == 6): 
     140                        #init_byte_size = serial.SIXBITS 
     141                #elif (bytesize == 7): 
     142                        #init_byte_size = serial.SEVENBITS 
     143                #elif (bytesize == 8): 
     144                        #init_byte_size = serial.EIGHTBITS 
     145                #else: 
     146                        ##self.log.perror("Invalid value for %s modem byte size! Using default (8)" % modem_type) 
     147                        #init_byte_size = serial.EIGHTBITS 
     148                 
     149                ## convert parity 
     150                #if (parity == 'NONE'): 
     151                        #init_parity = serial.PARITY_NONE 
     152                #elif (parity == 'EVEN'): 
     153                        #init_parity = serial.PARITY_EVEN 
     154                #elif (parity == 'ODD'): 
     155                        #init_parity = serial.PARITY_ODD 
     156                #else: 
     157                        ##self.log.perror("Invalid value for %s modem parity! Using default (NONE)" % modem_type) 
     158                        #init_parity = serial.PARITY_NONE 
     159                 
     160                ## convert stopbits 
     161                #if (stopbits == 1): 
     162                        #init_stopbits = serial.STOPBITS_ONE 
     163                #elif (stopbits == 2): 
     164                        #init_stopbits = serial.STOPBITS_TWO 
     165                #else: 
     166                        ##self.log.perror("Invalid value for %s modem stopbits! Using default (8)" % modem_type) 
     167                        #init_byte_size = serial.STOPBITS_ONE 
     168                 
     169                ## convert software flow control 
     170                #if (software_flow_control == 't'): 
     171                        #init_software_flow_control = 1 
     172                #else: 
     173                        #init_software_flow_control = 0 
     174                 
     175                ## convert rts cts flow control 
     176                #if (rts_cts_flow_control == 't'): 
     177                        #init_rts_cts_flow_control = 1 
     178                #else: 
     179                        #init_rts_cts_flow_control = 0 
     180                 
     181                 
     182                ## Initialize the modem 
     183                ##self.log.pdebug("Initializing %s modem" % modem_code) 
     184                 
     185                #device = serial.Serial(port = serial_port, \ 
     186                                            #baudrate = baudrate, \ 
     187                                            #bytesize = init_byte_size, \ 
     188                                            #parity = init_parity, \ 
     189                                            #stopbits = init_stopbits, \ 
     190                                            #xonxoff = init_software_flow_control, \ 
     191                                            #rtscts = init_rts_cts_flow_control, \ 
     192                                            #timeout = timeout) 
     193                 
     194                 
     195                #return(device) 
    180196         
    181197         
     
    449465                valid_checksum = False 
    450466                 
    451                 if self.DEBUG > 2: 
     467                if self.DEBUG > 3: 
    452468                        print packet 
    453469                 
     
    463479                packet_length = packet_length.encode("hex") 
    464480                packet_length = int(packet_length, 16) 
     481                 
     482                print "packet_length:", 
     483                print packet_length 
     484                print "  len(packet):", 
     485                print len(packet) 
     486                 
    465487                 
    466488                if ((packet_length <= 169) and \ 
     
    570592                 
    571593                 
    572                 if ((self.DEBUG > 2) and \ 
     594                if ((self.DEBUG > 3) and \ 
    573595                         ((self.byte_count >= DEBUG_BYTE_COUNT) or \ 
    574596                          (self.packet_count >= DEBUG_PACKET_COUNT))): 
     
    581603        ################################################################## 
    582604         
    583         def start(self): 
    584                  
    585                 self.buffer = '' 
    586                 self.packet_count = 0 
    587                 self.byte_count = 0 
    588                  
    589                 while True: 
    590                          
    591                         byte = self.device.read() 
    592                          
    593                         if (len(byte) != 0): 
    594                                 if DEBUG > 2: 
    595                                         print byte 
     605        #def start(self): 
     606                 
     607                #self.buffer = '' 
     608                #self.packet_count = 0 
     609                #self.byte_count = 0 
     610                 
     611                #while True: 
     612                         
     613                        #byte = self.device.read() 
     614                         
     615                        #if (len(byte) != 0): 
     616                                #if DEBUG > 3: 
     617                                        #print byte 
    596618                                         
    597                                 self.process_byte(byte) 
     619                                #self.process_byte(byte) 
    598620         
    599621         
     
    690712                         
    691713                         
    692                         if self.DEBUG > 1: 
     714                        if self.DEBUG > 3: 
    693715                                packet_count += 1 
    694716                                if packet_count >= DEBUG_PACKET_COUNT: 
     
    696718                                        self.device.close() 
    697719                                        sys.exit() 
     720         
     721         
     722        ################################################################## 
     723         
     724        def run(self): 
     725                 
     726                self.parse_stream() 
     727 
     728 
     729##################################################################### 
     730##################################################################### 
     731 
     732class puzzlebox_thinkgear_serial_device(QtCore.QThread): 
     733         
     734        def __init__(self, log, \ 
     735                               serial_port=DEFAULT_SERIAL_PORT, \ 
     736                               DEBUG=DEBUG, \ 
     737                               parent=None): 
     738                 
     739                QtCore.QThread.__init__(self,parent) 
     740                 
     741                self.log = log 
     742                self.DEBUG = DEBUG 
     743                 
     744                self.serial_port = serial_port 
     745                self.device = None 
     746                self.buffer = '' 
     747                 
     748                self.device = self.initialize_device() 
     749         
     750         
     751        ################################################################## 
     752         
     753        def initialize_device(self): 
     754                 
     755                baudrate = DEFAULT_SERIAL_BAUDRATE 
     756                bytesize = 8 
     757                parity = 'NONE' 
     758                stopbits = 1 
     759                software_flow_control = 'f' 
     760                rts_cts_flow_control = 'f' 
     761                #timeout = 15 
     762                timeout = 5 
     763                 
     764                # convert bytesize 
     765                if (bytesize == 5): 
     766                        init_byte_size = serial.FIVEBITS 
     767                elif (bytesize == 6): 
     768                        init_byte_size = serial.SIXBITS 
     769                elif (bytesize == 7): 
     770                        init_byte_size = serial.SEVENBITS 
     771                elif (bytesize == 8): 
     772                        init_byte_size = serial.EIGHTBITS 
     773                else: 
     774                        #self.log.perror("Invalid value for %s modem byte size! Using default (8)" % modem_type) 
     775                        init_byte_size = serial.EIGHTBITS 
     776                 
     777                # convert parity 
     778                if (parity == 'NONE'): 
     779                        init_parity = serial.PARITY_NONE 
     780                elif (parity == 'EVEN'): 
     781                        init_parity = serial.PARITY_EVEN 
     782                elif (parity == 'ODD'): 
     783                        init_parity = serial.PARITY_ODD 
     784                else: 
     785                        #self.log.perror("Invalid value for %s modem parity! Using default (NONE)" % modem_type) 
     786                        init_parity = serial.PARITY_NONE 
     787                 
     788                # convert stopbits 
     789                if (stopbits == 1): 
     790                        init_stopbits = serial.STOPBITS_ONE 
     791                elif (stopbits == 2): 
     792                        init_stopbits = serial.STOPBITS_TWO 
     793                else: 
     794                        #self.log.perror("Invalid value for %s modem stopbits! Using default (8)" % modem_type) 
     795                        init_byte_size = serial.STOPBITS_ONE 
     796                 
     797                # convert software flow control 
     798                if (software_flow_control == 't'): 
     799                        init_software_flow_control = 1 
     800                else: 
     801                        init_software_flow_control = 0 
     802                 
     803                # convert rts cts flow control 
     804                if (rts_cts_flow_control == 't'): 
     805                        init_rts_cts_flow_control = 1 
     806                else: 
     807                        init_rts_cts_flow_control = 0 
     808                 
     809                 
     810                # Initialize the modem 
     811                #self.log.pdebug("Initializing %s modem" % modem_code) 
     812                 
     813                device = serial.Serial(port = serial_port, \ 
     814                                            baudrate = baudrate, \ 
     815                                            bytesize = init_byte_size, \ 
     816                                            parity = init_parity, \ 
     817                                            stopbits = init_stopbits, \ 
     818                                            xonxoff = init_software_flow_control, \ 
     819                                            rtscts = init_rts_cts_flow_control, \ 
     820                                            timeout = timeout) 
     821                 
     822                 
     823                return(device) 
     824         
     825         
     826        ################################################################## 
     827         
     828        def read(self, length=1): 
     829                 
     830                # Sleep for 2 ms if buffer is empty 
     831                # Based on 512 Hz refresh rate of NeuroSky MindSet device 
     832                # (1/512) * 1000 = 1.9531250 
     833                while len(self.buffer) < length: 
     834                        QtCore.QThread.msleep(2) 
     835                         
     836                bytes = self.buffer[:length] 
     837                 
     838                self.buffer = self.buffer[length:] 
     839                 
     840                return(bytes) 
     841         
     842         
     843        ################################################################## 
     844         
     845        def close(self): 
     846         
     847                self.device.close() 
     848         
     849         
     850        ################################################################## 
     851         
     852        def run(self): 
     853                 
     854                #if self.DEBUG: 
     855                        #print "<---- [%s]: Main thread running" % self.socket.name 
     856                        #self.exec_() 
     857                 
     858                self.buffer = '' 
     859                 
     860                while True: 
     861                         
     862                        byte = self.device.read() 
     863                         
     864                        if (len(byte) != 0): 
     865                                if DEBUG > 3: 
     866                                        print "Device read:", 
     867                                        print byte 
     868                                         
     869                                self.buffer += byte 
    698870 
    699871 
     
    705877         
    706878        # Perform correct KeyboardInterrupt handling 
    707         #signal.signal(signal.SIGINT, signal.SIG_DFL) 
     879        signal.signal(signal.SIGINT, signal.SIG_DFL) 
    708880         
    709881        #log = puzzlebox_logger.puzzlebox_logger(logfile='server_thinkgear') 
     
    719891         
    720892         
    721         #app = QtCore.QCoreApplication(sys.argv) 
    722          
    723         server = puzzlebox_thinkgear_serial_protocol(log, \ 
    724                                                            serial_port, \ 
    725                                                            DEBUG=DEBUG) 
    726          
    727         #sys.exit(app.exec_()) 
    728          
    729         #server.start() 
    730          
    731         server.parse_stream() 
    732          
    733          
     893        app = QtCore.QCoreApplication(sys.argv) 
     894         
     895        serial_device = puzzlebox_thinkgear_serial_device(log, \ 
     896                                                               serial_port, \ 
     897                                                               DEBUG=DEBUG) 
     898        serial_device.start() 
     899         
     900        protocol = puzzlebox_thinkgear_serial_protocol(log, \ 
     901                                                            serial_device, \ 
     902                                                            serial_port, \ 
     903                                                            DEBUG=DEBUG) 
     904         
     905        #server.parse_stream() 
     906        protocol.start() 
     907         
     908        sys.exit(app.exec_()) 
     909         
     910         
     911         
Note: See TracChangeset for help on using the changeset viewer.