将字节流反序列化为对象

Question

我正在构建一个从串行端口接收字节的python项目。字节是对发送命令的响应（也是通过串行端口）。答案没有识别标记，即仅来自字节，我不知道这是哪个命令响应。解码器当然需要事先知道这是一个响应的命令。

我希望传入的字节序列表示为嵌套对象，指示帧，标头，有效载荷，解码的有效载荷等。我更喜欢每次向解码器推送1个字节并让它调用回调一旦它已经收到足够的字节为一个完整的对象（或errorCallback如果有错误或超时）。

实际的帧有一个开始字节和一个结束字节。它有一个包含几个字节（一些id，命令状态（基本上是ok/fail））的头部，一个是数据长度字节。紧接着是一个校验和（单字节）的数据。数据是对命令的响应。

响应是可预测的，因为前面的字节决定了即将到来的字节的含义。

实施例响应：

AA：00：0C：00：01：00：00：D3：8D：D4：5C：50：01：04：E0：6E：BB

分拆下来：

aa: start frame 
    00: id 
    0c: data length (incl status): 12 bytes 
    00: command status (byte 1) 
     01: 1 data frame (byte 2) 
      00:00: flags of first data frame (byte 3-4) 
      d3:8d:d4:5c:50:01:04:e0: first data (aa and bb could be in it) (byte 5-12) 
    6e: checksum (includes all bytes except start, checksum, end bytes) 
bb: end frame 

这是串行端口通信，字节可能丢失（和额外的生产）和我希望使用超时来处理重置（无响应预期没有被发送的第一命令）。

我真的想要一个面向对象的方法，其中的解码器将产生一个对象，当序列化时，会再次产生相同的字节序列。我使用python 2.7，但真正的任何面向对象的语言都可以（只要我可以将它转换为python）。

我只是不知道如何构造解码器，使它看起来整洁。我正在寻找一个完整的解决方案，只是让我朝着正确的方向前进（正确的方向有点主观）。

Answer 1

我不完全明白你想要做什么，但如果你想从一些设备接收固定长度的反应，使他们的一些对象的属性，将这样的事情会好起来？：

START_FRAME = 0xAA 
END_FRAME = 0xBB 
TIMEOUT = 2 

class Response: 
def __init__(self, response): 
    if (len(response) - 6) % 11 == 0 and response[0] == START_FRAME and response[-1] == END_FRAME: # verify that its a valid response 
     self.header = {} # build header 
     self.header['id'] = response[1] 
     self.header['length'] = response[2] 
     self.header['status'] = response[3] 
     self.r_checksum = response[-2] # get checksum from response 
     self.checksum = self.header['id']^self.header['length']^self.header['status'] # verify the checksum 
     self.payload = response[4:-2] # get raw payload slice 
     self.decode(self.payload) # parse payload 
     if self.r_checksum == self.checksum: # final check 
      self.parsed = True 
     else: 
      self.parsed = False 
    else: # if response didnt follow the pattern 
     self.parsed = False 
def decode(self, packet): # decode payload 
    self.frm_count = packet[0] # get number of data frames 
    self.checksum ^= self.frm_count 
    self.decoded = [] # hold decoded payload 
    frames = packet[1:] 
    for c in range(self.frm_count): # iterate through data frames 
     flags = frames[(c*10):(c*10 + 2)] 
     for f in flags: 
      self.checksum ^= f 
     data = frames[(c*10 + 2):(c+1)*10] 
     for d in data: 
      self.checksum ^= d 
     self.decoded.append({'frame': c+1, 'flags': flags, 'data':data}) 
def serialize(): # reconstruct response 
    res = bytearray() 
    res.append(START_FRAME) 
    res.extend([self.header['id'], self.header['length'], self.header['status']]) 
    res.extend(self.payload) 
    res.extend([self.checksum, END_FRAME]) 
    return res 

response = bytearray() 
ser = serial.Serial('COM3', 9600) # timeout is 2 seconds 
last_read = time.clock() 
while time.clock() - last_read < TIMEOUT: 
    while ser.inWaiting() > 0: 
     response.append(ser.read()) 
     last_read = time.clock() 
decoded_res = Response(response) 
if decoded_res.parsed: 
    # do stuff 
else: 
    print('Invalid response!') 

该代码假定可能有多个数据帧，数据帧之前是一个指示数据帧数量的字节。 与串行通信（即使在115200波特）相比，解析数据包的速度更快。整个事情大概是O（n），我想。