使用Python的BitString

Question

我正在尝试使用python的位字符串来解释传入的数据包并将其分解为可读部分。 数据包将包含一个标头（源（8位），目标（8位），NS（3位），NR（3位），RSV（1位），LST（1位），OPcode（8位），LEN（8位）），有效负载介于0到128个字节之间（由标头中的LEN确定），并具有16位CRC。

数据将通过com端口以大数据包的形式到达。 数据源自微控制器，该微控制器将数据打包并将其发送给用户，这是python发挥作用的地方。

由于我不确定在解析之前如何存储它，因此我没有任何代码。

我是python的新手，需要一点帮助来使它起步。

谢谢，埃里克

编辑

我目前有一段代码可以运行，但是并不能完全满足我的需求。...这是我已经运行的代码部分。

def packet_make(ser):
    src = 10
    p = 0
    lst = 0
    payload_make = 0
    crc = '0x0031'
    ns = 0
    nr = 0
    rsv = 0
    packet_timeout = 0

    top = 256
    topm = 255

    #os.system(['clear','cls'][os.name == 'nt'])
    print("\tBatts:   1 \t| Berry:   2 \t| Bessler: 3")
    print("\tCordell: 4 \t| Dave:    5 \t| Gold:    6")
    print("\tYen:     7   \t| Erik:    8 \t| Tommy:   9")
    print("\tParsons: 10 \t| JP:     11 \t| Sucess: 12")
    dst = raw_input("Please select a destination Adderss: ")

    message = raw_input("Please type a message: ")



    #################### Start Making packet#################
    p_msg = message
    message = message.encode("hex")
    ln = (len(message)/2)
    #print (ln)
    ln_hex = (ln * 2)
    message = list(message)
    num_of_packets = ((ln/128) + 1)
    #print (num_of_packets)

    message = "".join(message)

    src = hex(src)
    dst = hex(int(dst))
    #print (message)

    print("\n########Number of packets = "+str(num_of_packets) + " ############\n\n")

    for p in range (num_of_packets):
        Ack_rx = 0


        if( (p + 1) == (num_of_packets)):
            lst = 1
        else:
            lst = 0

        header_info = 0b00000000

        if ((p % 2) > 0):
            ns = 1
        else:
            ns = 0  


        header_info = (header_info | (ns << 5)) 
        header_info = (header_info | (nr << 2))
        header_info = (header_info | (rsv << 1))
        header_info = (header_info | (lst))
        header_info = hex(header_info)
        #print (header_info)
        op_code = '0x44'

        if (lst == 1):
            ln_packet = ((ln_hex - (p * 256)) % 256)
            if (p > 0):
                ln_packet = (ln_packet + 2)
            else:
                ln_packet = ln_packet
            ln_packet = (ln_packet / 2)
        #   print (ln_packet)
        #   print()
        else:
            ln_packet = 128
        #   print(ln_packet)
        #   print()

        #ll = (p * 128)
        #print(ll)
        #ul = ((ln - ll) % 128)
        #print(ul)
        #print (message[ll:ul])

        if ((p == 0)&(ln_hex > 256)):
            ll = (p * 255)
        #   print(ll)
            payload_make = (message[ll:256])
        #   print (payload_make)
        elif ((p > 0) & ((ln_hex - (p*256)) > 256)):
            ll = (p * 256)
        #   print(ll)
            ll = (ll - 2)
            ul = (ll + 256)
        #   print (ul)

            payload_make = (message[ll:ul])
        #   print(payload_make)
        elif ((p > 0) & ((ln_hex - (p*256)) < 257)):
            ll = (p * 256)
        #   print(ll)
            ll = (ll - 2)
            ul = ((ln_hex - ll) % 256)

            ul = (ll + (ul))
            ul = ul + 2
            print()
            print(ul)
            print(ln_hex)
            print(ln_packet)
            print()
        #   print(ul)
            payload_make = (message[ll:ul])
        #   print(payload)
        elif ((p == 0) & (ln_hex < 257)):
            ll = (p * 255)
            ul = ln_hex
            payload_make = (message[ll:ul])

        print(payload_make)

        packet_m = BitStream()  
########################HEADER#########################
        packet_m.append('0x0')
        packet_m.append(src)                        #src
        packet_m.append('0x0')  
        packet_m.append(dst)                        #dst
        if(int(header_info,16) < 16):
            packet_m.append('0x0')
        packet_m.append(header_info)                # Ns, Nr, RSV, Lst
        packet_m.append(op_code)                    #op Code
        #if(ln_packet < 16):
            #packet_m.append('0x0')
        packet_m.append((hex(ln_packet)))           #Length
###################END OF HEADER#######################     
        packet_m.append(("0x"+payload_make))    #Payload
        #packet_m.append(BitArray(p_msg))   #Payload
        packet_m.append(crc)                    #CRC    
        #print()
        #print(packet)
        temp_ack = '0x00'
        print(packet_m)
        print(ln_packet)
        while((Ack_rx == 0) & (packet_timeout <= 5)):
            try: 
                ###### Send the packet
                #ser.write(chr(0x31))

                str_pack = list(str(packet_m)[2:])
                "".join(str_pack)

                ser.write(chr(0x02))
                #ser.write((str(packet_m)[2:]))
                for i in range (len(str_pack)):
                    t = ord(str_pack[i])
                    ser.write(chr(t))
                    print(chr(t))


                ser.write(chr(0x04))
                ser.write(chr(0x10))

                ack_packet = BitStream(ser.read())
                if((len(ack_packet) > 3)):
                    temp_ack = ACK_parse(ack_packet)
                else:
                    packet_timeout = (packet_timeout + 1)
                    print "why so serious\n\n"
                if(temp_ack == '0x41'):
                    Ack_rx = 1
                elif (temp_ack == '0x4E'):
                    Ack_rx = 0
                else:
                    Acl_rx = 0 

            except serial.SerialTimeoutException: #if timeout occurs increment counter and resend last packet
                Ack_rx = 0
                packet_timeout = (packet_timeout + 1)


            except serial.SerialException:
                print "Error ... is not Active!!!", port

当源和有效负载均为1时，输出到终端的输出如下：

#######Number of packets = 1 #######

31
0x0a0101441310031
1
0
.... etc..

串行另一端的micro读取0a0101441310031时应读取1 1 44 1 31 0031

Python将每个值作为一个单独的字符发送，而不是将其作为一个字符发送。 当将其附加到数据包中而不是存储到适当的长度和数据类型中时，似乎已将十六进制分隔为2 8位，而不是1 8位。

我从Micro读取的python代码部分在读取确认数据包时可以正常工作。 我没有用数据尝试过，但是我认为这不会成为问题。 C端无法从python端读取ACK，因为它将十六进制值分成2个字符，而不是仅发送8位值。

有任何想法吗？？？ 谢谢

Answer 1

您的确切问题有点含糊，但是我应该可以在它的位串部分中提供帮助。

您可能已经将您的有效负载作为str进行了分析（如果您使用的是Python 3，则可能为bytes ，但不用担心-它的工作方式相同）。 如果您还没走那么远，那么您将不得不问一个更基本的问题。 我将组成一些数据进行分析（所有这些都是通过交互式Python会话完成的）：

>>> from bitstring import BitStream
>>> packet_data = '(2\x06D\x03\x124V\x03\xe8'
>>> b = BitStream(bytes=packet_data)

现在，您可以对BitStream进行解压缩或使用读取来提取所需的内容。 例如：

>>> b.read('uint:8')
40
>>> b.read('uint:8')
50
>>> b.readlist('uint:3, uint:3')
[0, 1]
>>> b.readlist('2*bool')
[True, False]
>>> b.readlist('2*uint:8')
[68, 3]
>>> b.read('bytes:3')
'\x124V'

这只是解析字节并将块解释为无符号整数，布尔值或字节。 请查看手册以了解更多详细信息。

如果只需要有效负载，则可以提取长度，然后通过切片来获取：

>>> length = b[32:40].uint
>>> b[40:40 + length*8]
BitStream('0x123456')

如果希望将其作为Python str返回，则使用字节解释：

>>> b[40:40 + 3*8].bytes
'\x124V'

您还可以做更多高级的事情，但是使用Python的好方法通常是打开一个交互式会话并尝试一些事情。