BitString与python

Question

我正在尝试使用bitstring for python来解释传入的数据包并将其分解为可读部分.数据包将由一个标题(源(8位),目标(8位),NS(3位),NR(3位),RSV(1位),LST(1位),OPcode(8位),LEN(8位))组成,有效载荷介于0到128字节之间(由标题中的LEN确定)和CRC为16位.

数据将通过com端口到达大数据包.这些数据来自一个微控制器,它将数据打包并发送给用户,这是python进入的地方.

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

我是python的新手,需要一些帮助才能实现这一目标.

谢谢,Erik

编辑

我目前有一段代码正在运行,但它并没有完全按照我的需要生成....这是我已启动并运行的代码部分....

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将每个值作为单独的字符发送,而不是将其作为一个char.当它被附加到数据包而不是存储到适当的长度和数据类型时,似乎已将十六进制分成2个8位位置而不是1 8位位置....

我正在阅读微信的python代码部分在读取确认包时完美无缺.我没有尝试过数据,但我认为这不会成为一个问题.C端无法从python端读取ACK,因为它将十六进制值分成2个字符而不是仅传输8位值....

有任何想法吗？？？谢谢

Answer 1

你确切的问题有点模糊,但我应该能够帮助它的bitstring部分.

您可能已将有效负载分析为str(或者bytes如果您使用的是Python 3,但不要担心 - 它的工作方式相同).如果你没有那么远,那么你将不得不提出一个更基本的问题.我将编制一些数据进行分析(所有这些都是通过交互式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'

这只是解析字节并将块解释为无符号整数,bools或字节.有关详细信息,请查看手册.

如果你只想要有效载荷,那么你可以只提取长度然后通过切片抓取它:

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

如果你想把它作为Python str,那么使用字节解释:

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

你还可以做更多先进的事情,但是在Python中使用的好方法通常是打开一个交互式会话并尝试一些事情.