Changeset 122


Ignore:
Timestamp:
07/23/10 10:42:47 (11 years ago)
Author:
sc
Message:

thinkgear_emulator/puzzlebox_thinkgear_serial_protocol.py:

  • data payload parsing complete
File:
1 edited

Legend:

Unmodified
Added
Removed
  • thinkgear_emulator/puzzlebox_thinkgear_serial_protocol.py

    r121 r122  
    1212# 
    1313##################################################################### 
    14 # Example: 
     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# Linux Bluetooth serial protocol profile example: 
    1544#    rfcomm connect rfcomm0 00:13:EF:00:1B:FE 3 
     45##################################################################### 
     46# TODO: 
     47# - needs to handle: 
     48#   serial.serialutil.SerialException:  
     49#   could not open port /dev/rfcomm0:  
     50#   [Errno 16] Device or resource busy: '/dev/rfcomm0' 
    1651##################################################################### 
    1752 
     
    4176 
    4277DEFAULT_MINDSET_ADDRESS = '00:13:EF:00:1B:FE' 
     78 
     79PROTOCOL_SYNC = 'xAA' 
     80PROTOCOL_EXCODE = '\x55' 
     81 
     82DEBUG_BYTE_COUNT = 8192 
     83DEBUG_PACKET_COUNT = 12 
    4384 
    4485##################################################################### 
     
    114155                else: 
    115156                        init_software_flow_control = 0 
    116  
     157                 
    117158                # convert rts cts flow control 
    118159                if (rts_cts_flow_control == 't'): 
     
    240281        ################################################################## 
    241282         
     283        def process_data_row(self, row, extended_code_level): 
     284                 
     285                pass 
     286         
     287         
     288        ################################################################## 
     289         
    242290        def process_data_payload(self, data_payload): 
    243291                 
    244                 pass 
     292                '''A DataRow consists of bytes in the following format: 
     293                ([EXCODE]...) [CODE] ([VLENGTH])   [VALUE...] 
     294                ____________________ ____________ ___________ 
     295                ^^^^(Value Type)^^^^ ^^(length)^^ ^^(value)^^''' 
     296                 
     297                if self.DEBUG > 1: 
     298                        print "data payload:", 
     299                        for byte in data_payload: 
     300                                print byte.encode("hex"), 
     301                        print 
     302                 
     303                byte_index = 0 
     304                 
     305                # Parse the extended_code_level, code, and length 
     306                while (byte_index < len(data_payload)): 
     307                        extended_code_level = 0 
     308                         
     309                        # 1. Parse and count the number of [EXCODE] (0x55) 
     310                        #    bytes that may be at the beginning of the 
     311                        #    current DataRow. 
     312                        while (data_payload[byte_index] == PROTOCOL_EXCODE): 
     313                                extended_code_level += 1 
     314                                byte_index += 1 
     315                         
     316                        # 2. Parse the [CODE] byte for the current DataRow. 
     317                        code = data_payload[byte_index] 
     318                        byte_index += 1 
     319                        code = code.encode("hex") 
     320                         
     321                        # 3. If [CODE] >= 0x80, parse the next byte as the  
     322                        #    [VLENGTH] byte for the current DataRow. 
     323                        if (code > '\x7f'.encode("hex")): 
     324                                length = data_payload[byte_index] 
     325                                byte_index += 1 
     326                                length = length.encode("hex") 
     327                                length = int(length, 16) 
     328                        else: 
     329                                length = 1 
     330                         
     331                        #TODO: Based on the extendedCodeLevel, code, length, 
     332                        #and the [CODE] Definitions Table, handle the next 
     333                        #"length" bytes of data from the payload as 
     334                        #appropriate for your application. 
     335                         
     336                        print "EXCODE level:", 
     337                        print extended_code_level, 
     338                        print " CODE:", 
     339                        print code, 
     340                        print " length:", 
     341                        print length 
     342                         
     343                        data_values = '' 
     344                        value_index = 0 
     345                         
     346                        # 4. Parse and handle the [VALUE...] byte(s) of the current  
     347                        #    DataRow, based on the DataRow's [EXCODE] level, [CODE],  
     348                        #    and [VLENGTH] (refer to the Code De nitions Table). 
     349                        while value_index < length: 
     350                                # Uh-oh more C mojo 
     351                                value = data_payload[(byte_index + value_index)] # & 0xFF 
     352                                data_values += value.encode("hex") 
     353                                value_index += 1 
     354                         
     355                        print "Data Values:", 
     356                        print data_values 
     357                        print 
     358                         
     359                        byte_index += length 
     360                         
     361                        # 5. If not all bytes have been parsed from the payload[] array, 
     362                        # return to step 1. to continue parsing the next DataRow. 
    245363         
    246364         
     
    248366         
    249367        def process_packet(self, packet): 
     368                 
     369                '''Each Packet begins with its Header, followed by its Data Payload,  
     370                and ends with the Payload's Check-sum Byte, as follows: 
     371                [SYNC] [SYNC] [PLENGTH]      [PAYLOAD...]         [CHKSUM] 
     372                _______________________      _____________     ____________ 
     373                ^^^^^^^^(Header)^^^^^^^      ^^(Payload)^^     ^(Checksum)^''' 
    250374                 
    251375                valid_length = False 
     
    269393                if ((packet_length <= 169) and \ 
    270394                         (packet_length + 4) == (len(packet))): 
     395                         
    271396                        if self.DEBUG > 1: 
    272397                                print "packet length correct" 
     398                         
    273399                        valid_length = True 
     400                 
    274401                else: 
    275402                        if self.DEBUG: 
     
    311438                                        print "       payload_checksum:", 
    312439                                        print payload_checksum 
     440                         
    313441                        else: 
    314442                                valid_checksum = True 
     
    370498                 
    371499                if ((self.DEBUG > 1) and \ 
    372                          ((self.byte_count >= 8192) or \ 
    373                           (self.packet_count >= 10))): 
     500                         ((self.byte_count >= DEBUG_BYTE_COUNT) or \ 
     501                          (self.packet_count >= DEBUG_PACKET_COUNT))): 
    374502                        if self.DEBUG: 
    375503                                print "max debugging count reached, disconnecting" 
Note: See TracChangeset for help on using the changeset viewer.