Python串口发送数据时出现运行时错误的问题（STM32F407 Bootloader开发场景）

我现在正在做软件bootloader的实现，用Python处理PC端的数据发送和接收确认信号，遇到了一个运行时错误：

Error waiting for acknowledgement: device reports readiness to read but returned no data (device disconnected or multiple access on port?)

以下是我的Python代码（STM32F407端的代码暂不相关）：

import time
import tkinter as tk
from tkinter import ttk, filedialog, messagebox
import serial
import serial.tools.list_ports
import os

class FirmwareUpdater:

    def __init__(self, root):
       self.root = root
       self.root.title("STM32F407 Firmware Upgrader")
       self.root.geometry("600x400")
       
       self.binary_file = None
       self.serial_port = None
       
       self.create_gui()
   
    def create_gui(self):
       # File Selection Frame
       file_frame = ttk.LabelFrame(self.root, text="Firmware File", padding="10")
       file_frame.pack(fill="x", padx=10, pady=5)
       
       self.file_path_var = tk.StringVar()
       ttk.Label(file_frame, textvariable=self.file_path_var).pack(side="left", fill="x", expand=True)
       ttk.Button(file_frame, text="Browse", command=self.browse_file).pack(side="right")
       
       # Serial Port Frame
       serial_frame = ttk.LabelFrame(self.root, text="Serial Port Settings", padding="10")
       serial_frame.pack(fill="x", padx=10, pady=5)
       
       ttk.Label(serial_frame, text="Port:").grid(row=0, column=0, padx=5)
       self.port_combo = ttk.Combobox(serial_frame, width=20)
       self.port_combo.grid(row=0, column=1, padx=5)

       # Progress Frame
       progress_frame = ttk.LabelFrame(self.root, text="Upload Progress", padding="10")
       progress_frame.pack(fill="x", padx=10, pady=5)
       
       self.progress_bar = ttk.Progressbar(progress_frame, orient=tk.HORIZONTAL, length=300, mode='determinate')
       self.progress_bar.pack(fill="x", pady=5)        
       
       self.status_var = tk.StringVar(value="Ready")
       ttk.Label(progress_frame, textvariable=self.status_var).pack()
       
       # Control Buttons
       button_frame = ttk.Frame(self.root)
       button_frame.pack(fill="x", padx=10, pady=5)
       
       ttk.Button(button_frame, text="Start", command=self.start_upload).pack(side="right", padx=5)
       
       # Initialize ports list
       self.get_ports()
   
    def get_ports(self):
       ports = ["/dev/ttyUSB0","/dev/ttyUSB1","/dev/ttyUSB2"]
       self.port_combo['values'] = ports
       if ports:
           self.port_combo.set(ports[0])

    def browse_file(self):
       filename = filedialog.askopenfilename(
           filetypes=[("Binary files", "*.bin")]
       )
       if filename:
           self.binary_file = filename
           self.file_path_var.set(os.path.basename(filename))
   
    def start_upload(self):
       if not self.binary_file:
           messagebox.showerror("Error", "Please select a firmware file first!")
           return
       
       if not self.port_combo.get():
           messagebox.showerror("Error", "Please select a serial port!")
           return
       
       try:
           print("Starting upload process...")
           # Read binary file
           with open(self.binary_file, 'rb') as f:
               firmware_data = f.read()

           # Just open the port once
           self.serial_port = serial.Serial(
               port=self.port_combo.get(),
               baudrate=115200,  
               timeout=2             
           )

            # Start the upload process
           firmware_data = self.add_padding_bytes(firmware_data)
           self.upload_firmware(firmware_data)
           
       except Exception as e:
           messagebox.showerror("Error", f"An error occurred: {str(e)}")


    def get_metadata(self, firmware_data):
       preamble = bytes([0x53,0x54,0x4D,0x33,0x32,0x5F,0x42,0x4F,0x4F,0x54,0x4C,0x4F,0x41,0x44,0x45,0x52,0x5F,0x56,0x30,0x31])
       firmware_size = len(firmware_data).to_bytes(4, 'little')
       checksum = self.calculate_checksum_metadata(preamble + firmware_size)
       return preamble + firmware_size + checksum

    def calculate_checksum_metadata(self, data):
       checksum = 0x00000000
       for i in range(0, len(data), 4):
           word = int.from_bytes(data[i:i+4], byteorder='little')
           checksum ^= word
       return checksum.to_bytes(4, 'little')
    
    def calculate_checksum_firmware(self,data):
        checksum = 0x00000000
        for byte in data:
            checksum ^= byte
        return checksum.to_bytes(4, 'little')
            
    def add_padding_bytes(self, data):
        padding_bytes = (64 - (len(data) % 64)) % 64
        return data + b'\x00' * padding_bytes
   
    def send_hold_signal(self):
       self.serial_port.write(b'\x55\x66\x77\x88')
       print("Hold signal sent")

    def send_metadata(self, firmware_data):
        metadata = self.get_metadata(firmware_data)
        self.serial_port.write(metadata)

    def send_checksum(self,firmware_data):
        checksum = self.calculate_checksum_firmware(firmware_data)
        self.serial_port.write(checksum)

    
    def data_send(self, byte_val):
        self.serial_port.write(bytes([byte_val]))


    def msg_send(self, buf):
        # Calculate checksum
        checksum = self.calculate_checksum_firmware(buf)

        # Send escaped data bytes
        for byte_val in buf:
            self.data_send(byte_val)

        # Send escaped checksum bytes
        for chk_byte in checksum:
            self.data_send(chk_byte)

        
    def wait_for_acknowledgement(self, timeout=2):
        """
        Wait for acknowledgement from bootloader
        
        :param timeout: Timeout in seconds
        :return: True if ACK received, False otherwise
        """
        try:
            # Set a timeout on the serial port
            self.serial_port.timeout = timeout
            
            # Read response
            response = self.serial_port.read(1)
            
            # Check for ACK signal (typically 'A')
            if response == b'A':
                print("Acknowledgement received")
                return True
            else:
                print(f"Unexpected response: {response}")
                return False
        
        except Exception as e:
            print(f"Error waiting for acknowledgement: {e}")
            return False
        finally:
            # Reset timeout to default
            self.serial_port.timeout = None



    def upload_firmware(self, firmware_data):
        """
        Upload firmware using simplified acknowledgement protocol
        """
        # Send hold signal and wait for ACK
        self.send_hold_signal()
        hold_ack = self.wait_for_acknowledgement()
        if not hold_ack:
            raise RuntimeError("Did not receive ACK for hold signal")

        # Send metadata and wait for ACK
        self.send_metadata(firmware_data)
        metadata_ack = self.wait_for_acknowledgement()
        if not metadata_ack:
            raise RuntimeError("Did not receive ACK for metadata")

        chunk_size = 64
        total_chunks = (len(firmware_data) + chunk_size - 1) // chunk_size
        
        # Configure progress bar
        self.progress_bar['maximum'] = total_chunks
        self.progress_bar['value'] = 0
        self.status_var.set("Uploading firmware...")
        
        for chunk_index in range(total_chunks):
            # Prepare chunk
            start = chunk_index * chunk_size
            end = min(start + chunk_size, len(firmware_data))
            chunk = firmware_data[start:end]
            
            # Send chunk
            transmission_successful = False
            max_retries = 3
            retry_count = 0
            
            while not transmission_successful and retry_count < max_retries:
                try:
                    # Send message
                    self.msg_send(chunk)
                    
                    # Wait for chunk acknowledgement
                    chunk_ack = self.wait_for_acknowledgement()
                    
                    if chunk_ack:
                        transmission_successful = True
                        # Update progress bar
                        self.progress_bar['value'] = chunk_index + 1
                        # Update status text
                        self.status_var.set(f"Uploading: {chunk_index + 1}/{total_chunks} chunks")
                        # Force GUI update
                        self.root.update_idletasks()
                        
                        print(f"Chunk {chunk_index + 1}/{total_chunks} sent successfully")
                    else:
                        retry_count += 1
                        print(f"Error receiving ACK for chunk {chunk_index + 1}. Retrying...")
                
                except Exception as e:
                    retry_count += 1
                    print(f"Error sending chunk {chunk_index + 1}: {e}")
            
            # Check if max retries exceeded
            if not transmission_successful:
                self.status_var.set("Upload failed")
                raise RuntimeError(f"Failed to send chunk {chunk_index + 1} after {max_retries} attempts")
        
        # Upload complete
        self.progress_bar['value'] = total_chunks
        self.status_var.set("Upload completed successfully!")
        messagebox.showinfo("Success", "Firmware uploaded successfully!")
        
        # Close serial port
        if self.serial_port and self.serial_port.is_open:
            self.serial_port.close()

你好，这个错误在串口通信开发里挺常见的，我帮你分析下可能的原因和对应的解决办法：

• 端口被其他程序占用：错误提示里明确提到了“multiple access on port”，这大概率是串口调试助手、STM32烧录工具（比如ST-Link Utility）这类程序正在占用你选中的串口。解决办法是关闭所有可能占用该端口的软件，或者重启电脑后再尝试；也可以用lsof /dev/ttyUSB0（Linux系统）或者Windows设备管理器里的“查看->显示隐藏的设备”来排查端口占用情况。

• 串口超时设置冲突：你在wait_for_acknowledgement方法里先设置了timeout=2，最后又把超时重置为None（无限等待），这种频繁修改超时参数的操作可能导致串口读取逻辑异常。建议保持超时设置一致，比如全程使用固定的超时时间（比如2秒），避免在不同操作间切换超时模式。

• 硬件连接不稳定：STM32的串口接线可能松动，或者USB转串口模块接触不良。可以检查一下接线是否正确（TX和RX要交叉连接，GND必须共地），也可以换个USB接口或者换个USB转串口模块试试；另外，STM32是否正确进入了Bootloader模式也很关键，确认下Bootloader的启动条件是否满足。

• Bootloader侧响应逻辑问题：虽然你说STM32端代码不相关，但还是要确认Bootloader在收到信号后确实会发送b'A'的ACK响应，而且响应时机是否正确。比如发送0x55 0x66 0x77 0x88的hold信号后，Bootloader有没有及时处理并返回ACK？可以先用串口调试助手手动发送该信号，看看是否能收到A的回复，以此排除Bootloader的问题。

• 串口参数不匹配：确认Python代码里设置的波特率（115200）、数据位、停止位、奇偶校验和STM32 Bootloader的设置完全一致，哪怕有一个参数不匹配都会导致通信失败，进而出现读取不到数据的错误。

• 代码操作顺序与延时问题：发送数据后，STM32需要一定时间处理并返回响应，你可以在发送完数据后加个短暂的延时，比如time.sleep(0.1)，再调用wait_for_acknowledgement方法；另外，wait_for_acknowledgement里只读取1字节的逻辑，要确保Bootloader确实只发送1字节的ACK，没有多余的数据干扰。

备注：内容来源于stack exchange，提问作者dinajs