pyserial实现Zmodem协议的代码

下面是一个使用 PySerial 实现 Zmodem 协议的示例代码：

import os
import time
import binascii
import serial
import sys

# Zmodem 帧起始字符
ZPAD = chr(0x2A) # '*'
ZDLE = chr(0x18) # Ctrl-X
ZDLEE = chr(0x58) # Ctrl-Z
ZBIN = chr(0xA) # '\n'
ZHEX = chr(0x8) # '\b'
ZBIN32 = chr(0xC) # Ctrl-L
ZCMD = chr(0x2) # Ctrl-B

# Zmodem 帧类型
ZRQINIT = ZPAD + ZPAD + ZDLE + ZCMD + 'r' + ZBIN
ZACK = ZDLE + ZDLE + 'A' + ZBIN
ZNAK = ZDLE + ZDLE + 'B' + ZBIN
ZFILE = ZDLE + ZDLE + 'F' + ZBIN
ZEOF = ZDLE + ZDLE + 'Z' + ZBIN32 + ZBIN32
ZFIN = ZDLE + ZDLE + 'f' + ZBIN
ZRPOS = ZDLE + ZDLE + 'P' + ZBIN32 + ZBIN32
ZDATA = ZDLE + ZDLE + 'D' + ZBIN
ZCRC = ZDLE + ZDLE + 'C' + ZBIN
ZCHALLENGE = ZDLE + ZDLE + 'G' + ZBIN32 + ZBIN32
ZCOMPL = ZDLE + ZDLE + 'h' + ZBIN

# Zmodem 帧最大长度
ZMAXLEN = 1024

class Zmodem:
    def __init__(self, serial):
        self.serial = serial
        self.buffer = ''
        self.offset = 0
        self.cancel = False
        self.timeout = 10 # 超时时间（秒）

    # 发送 Zmodem 帧
    def send_frame(self, frame):
        self.serial.write(frame)
        if frame == ZFIN:
            self.serial.flush()

    # 接收 Zmodem 帧
    def recv_frame(self):
        frame = ''
        while True:
            if self.cancel:
                return ''
            char = self.serial.read(1)
            if char == '':
                return ''
            self.buffer += char
            if len(self.buffer) >= 2 and self.buffer[-2:] == ZDLE + ZHEX:
                hexdata = self.buffer[-1:]
                self.buffer = self.buffer[:-2]
                data = binascii.a2b_hex(hexdata)
                frame += data
            elif len(self.buffer) >= 2 and self.buffer[-2:] == ZDLE + ZBIN:
                bindata = self.buffer[-1:]
                self.buffer = self.buffer[:-2]
                frame += bindata
            elif len(self.buffer) >= 3 and self.buffer[-3:] == ZDLE + ZDLEE + ZBIN:
                bindata = self.buffer[-2:]
                self.buffer = self.buffer[:-3]
                frame += bindata
            elif len(self.buffer) >= 2 and self.buffer[-2:] == ZDLE + ZDLEE:
                self.buffer = self.buffer[:-2]
                frame += ZDLE
            elif len(self.buffer) >= 1 and self.buffer[-1:] == ZPAD:
                self.buffer = ''
            elif len(self.buffer) >= 1 and self.buffer[-1:] == ZDLE:
                self.buffer = self.buffer[:-1]
            elif len(self.buffer) >= 1 and self.buffer[-1:] == ZBIN:
                self.buffer = self.buffer[:-1]
                frame += ZBIN
            elif len(self.buffer) >= 1 and self.buffer[-1:] == ZHEX:
                self.buffer = self.buffer[:-1]
                frame += ZHEX
            elif len(self.buffer) >= 1 and self.buffer[-1:] == ZCMD:
                self.buffer = self.buffer[:-1]
                return ''
            elif len(self.buffer) >= ZMAXLEN:
                self.buffer = ''
                return ''
            elif len(frame) >= 3 and frame[-3:] == ZDLE + ZDLE + 'B':
                return ''
            elif len(frame) >= 3 and frame[-3:] == ZDLE + ZDLE + 'A':
                return frame[:-3]

    # 发送文件
    def send_file(self, filename):
        filesize = os.path.getsize(filename)
        filename = os.path.basename(filename)
        frame = ZFILE + filename + ZBIN + str(filesize) + ' 644 ' + ZBIN
        self.send_frame(frame)
        response = self.recv_frame()
        if response != ZACK:
            return False
        with open(filename, 'rb') as f:
            data = f.read()
            crc = binascii.crc32(data) & 0xffffffff
            offset = 0
            while offset < len(data):
                if self.cancel:
                    return False
                chunk = data[offset:offset+1024]
                offset += 1024
                frame = ZDATA + chunk + ZCRC + self.crc32(chunk) + ZBIN
                self.send_frame(frame)
                response = self.recv_frame()
                if response != ZACK:
                    return False
        self.send_frame(ZEOF)
        response = self.recv_frame()
        if response != ZACK:
            return False
        return True

    # 接收文件
    def recv_file(self):
        filename = ''
        filesize = 0
        while True:
            if self.cancel:
                return False
            frame = ZRQINIT
            self.send_frame(frame)
            response = self.recv_frame()
            if response.startswith(ZFILE):
                filename = response[3:-2]
                filesize = int(response.split()[1])
                frame = ZACK
                self.send_frame(frame)
                break
            elif response == ZFIN:
                return False
            else:
                self.send_frame(ZNAK)
        with open(filename, 'wb') as f:
            received = 0
            while received < filesize:
                if self.cancel:
                    return False
                frame = ZRPOS + chr((received >> 24) & 0xff) + chr((received >> 16) & 0xff) + chr((received >> 8) & 0xff) + chr(received & 0xff) + ZBIN
                self.send_frame(frame)
                response = self.recv_frame()
                if response != ZACK:
                    return False
                frame = ZACK
                self.send_frame(frame)
                response = self.recv_frame()
                if not response.startswith(ZDATA):
                    return False
                data = response[2:-4]
                crc = response[-4:-2]
                if self.crc32(data) != crc:
                    return False
                f.write(data)
                received += len(data)
            self.send_frame(ZACK)
            response = self.recv_frame()
            if response != ZFIN:
                return False
            self.send_frame(ZACK)
        return True

    # 计算 CRC32 校验值
    def crc32(self, data):
        crc = binascii.crc32(data) & 0xffffffff
        return chr((crc >> 24) & 0xff) + chr((crc >> 16) & 0xff) + chr((crc >> 8) & 0xff) + chr(crc & 0xff)

    # 取消传输
    def cancel_transfer(self):
        self.cancel = True

if __name__ == '__main__':
    # 串口设置
    ser = serial.Serial()
    ser.port = '/dev/ttyUSB0'
    ser.baudrate = 115200
    ser.bytesize = serial.EIGHTBITS
    ser.parity = serial.PARITY_NONE
    ser.stopbits = serial.STOPBITS_ONE
    ser.timeout = 0.1
    ser.open()

    # Zmodem 对象初始化
    zm = Zmodem(ser)

    # 发送文件
    print('Sending file...')
    if zm.send_file('test.txt'):
        print('File sent successfully!')
    else:
        print('File transfer failed!')

    # 接收文件
    print('Receiving file...')
    if zm.recv_file():
        print('File received successfully!')
    else:
        print('File transfer failed!')

    # 关闭串口
    ser.close()

在上面的代码中，我们定义了一个 `Zmodem` 类来实现 Zmodem 协议的功能。该类包含以下方法：

- `__init__(self, serial)`: 类的构造函数，接受一个 PySerial 对象作为参数。
- `send_frame(self, frame)`: 发送一个 Zmodem 帧。
- `recv_frame(self)`: 接收一个 Zmodem 帧。
- `send_file(self, filename)`: 发送一个文件。
- `recv_file(self)`: 接收一个文件。
- `crc32(self, data)`: 计算 CRC32 校验值。
- `cancel_transfer(self)`: 取消传输。

在使用时，我们需要先创建一个 PySerial 对象，并设置好串口参数。然后，创建一个 `Zmodem` 对象，并传入该 PySerial 对象。接着，调用 `send_file` 方法发送文件，或调用 `recv_file` 方法接收文件。如果需要取消传输，可以调用 `cancel_transfer` 方法。最后，使用 `close` 方法关闭串口。

需要注意的是，上面的代码中使用了 PySerial 库和 binascii 库。因此，在运行代码前，我们需要先安装这两个库：

pip install pyserial

pip install binascii

另外，由于 Zmodem 协议是一种双向协议，因此在发送和接收文件时，我们需要在两个设备之间交替进行。也就是说，如果我们在设备 A 上发送文件，那么我们需要在设备 B 上接收文件；如果我们在设备 B 上发送文件，那么我们需要在设备 A 上接收文件。