backup codes

scripts/stm8loader.py

@@ -0,0 +1,931 @@
+#!/usr/bin/env python3
+"""
+STM8 Bootloader 交互工具
+支持自动检测并上传boot2程序，以及读写内存、执行等操作
+"""
+
+import sys
+import os
+import time
+import struct
+import argparse
+import serial
+from serial.tools import list_ports
+from typing import Optional, List, Tuple, Union, BinaryIO
+
+# ============ 协议常量定义 ============
+CMD_READ = 0xF1      # 读内存命令
+CMD_WRITE = 0xF2     # 写内存命令
+CMD_GO = 0xF3        # 跳转执行命令
+
+CMD_HEADER = 0x5A    # 发送给MCU的帧头
+ACK_HEADER = 0xA5    # MCU应答的帧头
+
+HANDSHAKE_ADDR = 0x8000  # 握手检测地址
+HANDSHAKE_SIZE = 8       # 握手数据长度
+
+BOOT1_BAUDRATE = 9600    # boot1波特率
+BOOT2_BAUDRATE = 128000  # boot2波特率
+
+FRAME_SIZE = 70          # 命令帧总大小
+MAX_DATA_SIZE = 64       # 单次最大数据长度
+
+class STM8BootloaderError(Exception):
+    """STM8 Bootloader异常基类"""
+    pass
+
+class STM8Bootloader:
+    def __init__(self, port: str, verbose: bool = False, reset_pin: str = 'rts'):
+        """
+        初始化STM8 Bootloader
+        
+        Args:
+            port: 串口号
+            verbose: 是否显示详细调试信息
+            reset_pin: 复位引脚类型 ('rts', 'dtr' 或 'none')
+        """
+        self.port = port
+        self.verbose = verbose
+        self.reset_pin = reset_pin.lower()
+        if self.reset_pin not in ['rts', 'dtr', 'none']:
+            raise ValueError("reset_pin 必须是 'rts', 'dtr' 或 'none'")
+        self.serial = None
+        self.in_boot2 = False
+        self.script_dir = os.path.dirname(os.path.abspath(__file__))
+        
+    def log(self, message: str, level: str = "INFO"):
+        """
+        打印日志信息
+        
+        Args:
+            message: 日志消息
+            level: 日志级别 (DEBUG, INFO, ERROR, WARNING)
+        """
+        if level == "DEBUG" and not self.verbose:
+            return
+            
+        prefix = f"[{level}]"
+        if level == "DEBUG":
+            prefix = f"[DEBUG] {message}"
+        elif level == "ERROR":
+            prefix = f"[ERROR] {message}"
+        elif level == "WARNING":
+            prefix = f"[WARNING] {message}"
+        else:
+            prefix = f"[INFO] {message}"
+            
+        print(prefix)
+    
+    def open(self, baudrate: int = BOOT2_BAUDRATE):
+        """打开串口连接"""
+        if self.serial is None or not self.serial.is_open:
+            self.serial = serial.Serial(
+                port=self.port,
+                baudrate=baudrate,
+                bytesize=serial.EIGHTBITS,
+                parity=serial.PARITY_NONE,
+                stopbits=serial.STOPBITS_ONE,
+                timeout=0.2  # 200ms超时
+            )
+            self.log(f"串口 {self.port} 已打开，波特率 {baudrate}", "DEBUG")
+    
+    def close(self):
+        """关闭串口连接"""
+        if self.serial and self.serial.is_open:
+            self.serial.close()
+            self.log("串口已关闭", "DEBUG")
+    
+    def reset_mcu(self) -> bool:
+        """
+        通过RTS或DTR复位MCU
+        
+        Returns:
+            True: 复位成功, False: 复位失败或未配置
+        """
+        if self.reset_pin == 'none':
+            self.log("未配置自动复位引脚，跳过自动复位", "INFO")
+            return True
+            
+        if not self.serial or not self.serial.is_open:
+            return False
+        
+        self.log(f"使用 {self.reset_pin.upper()} 引脚复位MCU...", "DEBUG")
+        
+        try:
+            if self.reset_pin == 'rts':
+                # RTS复位序列: True -> False -> True -> 等待150ms -> False
+                self.serial.setRTS(True)
+                time.sleep(0.01)  # 等待10ms稳定
+                
+                self.serial.setRTS(False)
+                time.sleep(0.01)  # 等待10ms稳定
+                
+                self.serial.setRTS(True)
+                time.sleep(0.15)  # 等待150ms，让MCU复位
+                
+                self.serial.setRTS(False)
+            else:  # dtr
+                # DTR复位序列: True -> False -> True -> 等待150ms -> False
+                self.serial.setDTR(True)
+                time.sleep(0.01)  # 等待10ms稳定
+                
+                self.serial.setDTR(False)
+                time.sleep(0.01)  # 等待10ms稳定
+                
+                self.serial.setDTR(True)
+                time.sleep(0.15)  # 等待150ms，让MCU复位
+                
+                self.serial.setDTR(False)
+            
+            # 等待MCU稳定
+            time.sleep(0.05)
+            self.log("MCU复位完成", "DEBUG")
+            return True
+            
+        except Exception as e:
+            self.log(f"复位失败: {e}", "ERROR")
+            return False
+    
+    def wait_for_boot1_signal_and_send_boot2(self, bin_file: str) -> bool:
+        """
+        等待boot1的握手信号 (0x00 0x0D)，收到后立即发送boot2.bin
+        
+        Args:
+            bin_file: boot2二进制文件路径
+            
+        Returns:
+            True: 成功, False: 失败
+        """
+        if not self.serial or not self.serial.is_open:
+            return False
+        
+        self.log("等待boot1握手信号(0x00 0x0D)...", "DEBUG")
+        
+        # 设置非阻塞读取
+        self.serial.timeout = 0  # 非阻塞
+        
+        try:
+            # 清除输入缓冲区
+            self.serial.reset_input_buffer()
+            
+            # 持续读取，最多等待200ms
+            start_time = time.time()
+            buffer = bytearray()
+            
+            while time.time() - start_time < 0.2:  # 200ms超时
+                # 读取所有可用数据
+                while self.serial.in_waiting > 0:
+                    data = self.serial.read(self.serial.in_waiting)
+                    buffer.extend(data)
+                    
+                    # 检查是否有0x00 0x0D
+                    if len(buffer) >= 2 and buffer[-2:] == b'\x00\x0d':
+                        self.log("收到boot1握手信号: 0x00 0x0D", "DEBUG")
+                        
+                        # 立即发送boot2.bin
+                        return self.send_boot2_binary(bin_file)
+                
+                # 短暂延时，避免CPU占用过高
+                time.sleep(0.001)  # 1ms
+            
+            # 超时，未收到信号
+            return False
+            
+        except Exception as e:
+            self.log(f"等待boot1信号时出错: {e}", "ERROR")
+            return False
+    
+    def wait_for_boot1_signal_blocking(self, bin_file: str) -> bool:
+        """
+        阻塞等待boot1的握手信号，直到收到并发送boot2或用户中断
+        
+        Returns:
+            True: 成功, False: 用户中断或失败
+        """
+        self.log("等待boot1握手信号...", "INFO")
+        self.log("请手动按下MCU复位键", "INFO")
+        self.log("按 Ctrl+C 退出程序", "INFO")
+        
+        # 设置非阻塞读取
+        self.serial.timeout = 0
+        
+        try:
+            while True:
+                # 检查是否有数据
+                while self.serial.in_waiting > 0:
+                    data = self.serial.read(self.serial.in_waiting)
+                    
+                    # 简单检查：如果数据包含0x00 0x0D
+                    if b'\x00\x0d' in data:
+                        self.log("收到boot1握手信号: 0x00 0x0D", "INFO")
+                        
+                        # 立即发送boot2.bin
+                        return self.send_boot2_binary(bin_file)
+                
+                # 短暂延时
+                time.sleep(0.001)
+                
+        except KeyboardInterrupt:
+            self.log("用户中断等待", "INFO")
+            return False
+        except Exception as e:
+            self.log(f"等待时出错: {e}", "ERROR")
+            return False
+    
+    def send_boot2_binary(self, bin_file: str) -> bool:
+        """
+        发送boot2.bin文件到MCU（字节倒序）
+        
+        Args:
+            bin_file: boot2二进制文件路径
+            
+        Returns:
+            True: 发送成功, False: 发送失败
+        """
+        try:
+            # 如果文件路径不是绝对路径，则相对于脚本目录
+            if not os.path.isabs(bin_file):
+                bin_file = os.path.join(self.script_dir, bin_file)
+            
+            with open(bin_file, 'rb') as f:
+                data = f.read()
+            
+            if not data:
+                self.log(f"文件 {bin_file} 为空", "ERROR")
+                return False
+            
+            self.log(f"读取到 {len(data)} 字节的boot2程序", "DEBUG")
+            
+            # 字节倒序
+            reversed_data = bytes(reversed(data))
+            
+            # 发送数据（不添加校验和）
+            self.serial.write(reversed_data)
+            self.serial.flush()
+            
+            self.log(f"已发送 {len(data)} 字节 (倒序)", "DEBUG")
+            return True
+            
+        except FileNotFoundError:
+            self.log(f"文件不存在: {bin_file}", "ERROR")
+            return False
+        except Exception as e:
+            self.log(f"发送boot2.bin时出错: {e}", "ERROR")
+            return False
+    
+    def calculate_checksum(self, data: bytes) -> int:
+        """计算XOR校验和"""
+        checksum = 0
+        for byte in data:
+            checksum ^= byte
+        return checksum
+    
+    def create_command_frame(self, cmd: int, addr: int, data: bytes = b'') -> bytes:
+        """
+        创建命令帧
+        
+        Args:
+            cmd: 命令类型
+            addr: 目标地址
+            data: 数据内容
+            
+        Returns:
+            完整的命令帧
+        """
+        if len(data) > MAX_DATA_SIZE:
+            raise STM8BootloaderError(f"数据长度超过{MAX_DATA_SIZE}字节限制")
+        
+        # 构建帧
+        frame = bytearray(FRAME_SIZE)
+        frame[0] = CMD_HEADER                    # 帧头
+        frame[1] = cmd                          # 命令类型
+        frame[2] = (addr >> 8) & 0xFF          # 地址高字节
+        frame[3] = addr & 0xFF                  # 地址低字节
+        frame[4] = len(data)                    # 数据长度
+        
+        # 填充数据
+        if data:
+            frame[5:5+len(data)] = data
+        
+        # 计算校验和（从帧头到数据结束）
+        checksum_data = frame[:5+len(data)]
+        frame[5+len(data)] = self.calculate_checksum(checksum_data)
+        
+        return bytes(frame[:5+len(data)+1])
+    
+    def parse_response_frame(self, frame: bytes) -> Tuple[int, int, bytes]:
+        """
+        解析应答帧
+        
+        Args:
+            frame: 接收到的帧数据
+            
+        Returns:
+            (命令类型, 地址, 数据)
+        """
+        if len(frame) < 6:
+            raise STM8BootloaderError("应答帧长度不足")
+        
+        if frame[0] != ACK_HEADER:
+            raise STM8BootloaderError(f"无效的应答帧头: 0x{frame[0]:02X}")
+        
+        # 验证校验和
+        received_checksum = frame[-1]
+        calculated_checksum = self.calculate_checksum(frame[:-1])
+        
+        if received_checksum != calculated_checksum:
+            raise STM8BootloaderError(f"校验和错误: 收到0x{received_checksum:02X}, 计算0x{calculated_checksum:02X}")
+        
+        cmd = frame[1]
+        addr = (frame[2] << 8) | frame[3]
+        data_len = frame[4]
+        
+        if len(frame) < 5 + data_len + 1:
+            raise STM8BootloaderError("应答帧数据长度不匹配")
+        
+        data = frame[5:5+data_len]
+        
+        return cmd, addr, data
+    
+    def send_command(self, cmd: int, addr: int, data: bytes = b'', 
+                    wait_response: bool = True, timeout: float = 0.2) -> Optional[Tuple[int, int, bytes]]:
+        """
+        发送命令并接收响应
+        
+        Args:
+            cmd: 命令类型
+            addr: 目标地址
+            data: 数据内容
+            wait_response: 是否等待响应
+            timeout: 超时时间
+            
+        Returns:
+            解析后的响应帧，或None
+        """
+        if not self.serial or not self.serial.is_open:
+            raise STM8BootloaderError("串口未打开")
+        
+        # 清除输入缓冲区
+        self.serial.reset_input_buffer()
+        
+        # 创建并发送命令帧
+        frame = self.create_command_frame(cmd, addr, data)
+        self.serial.write(frame)
+        self.serial.flush()
+        
+        if not wait_response:
+            return None
+        
+        # 等待响应
+        self.serial.timeout = timeout
+        response = self.serial.read(FRAME_SIZE)
+        
+        if not response:
+            raise STM8BootloaderError("未收到响应")
+        
+        return self.parse_response_frame(response)
+    
+    def check_boot2(self) -> bool:
+        """
+        检查是否已经在boot2中
+        
+        Returns:
+            True: 在boot2中, False: 不在boot2中
+        """
+        try:
+            self.log("检查是否在boot2中...", "DEBUG")
+            response = self.send_command(CMD_READ, HANDSHAKE_ADDR, b'', timeout=0.5)
+            
+            if response:
+                cmd, addr, data = response
+                if cmd == CMD_READ and addr == HANDSHAKE_ADDR and len(data) >= HANDSHAKE_SIZE:
+                    self.in_boot2 = True
+                    self.log("已在boot2中", "DEBUG")
+                    return True
+                    
+        except STM8BootloaderError as e:
+            self.log(f"不在boot2中: {e}", "DEBUG")
+        except Exception as e:
+            self.log(f"检查boot2时出错: {e}", "DEBUG")
+        
+        self.in_boot2 = False
+        return False
+    
+    def upload_boot2(self, boot2_file: str = "boot2.bin") -> bool:
+        """
+        上传boot2程序到MCU
+        
+        Args:
+            boot2_file: boot2二进制文件路径
+            
+        Returns:
+            True: 上传成功, False: 上传失败
+        """
+        self.log("开始上传boot2程序...", "INFO")
+        
+        # 1. 切换到9600bps
+        self.close()
+        self.open(baudrate=BOOT1_BAUDRATE)
+        time.sleep(0.05)  # 等待串口稳定
+        
+        # 2. 尝试复位MCU（如果配置了复位引脚）
+        if self.reset_pin != 'none':
+            if self.reset_mcu():
+                self.log("自动复位MCU成功", "INFO")
+            else:
+                self.log("自动复位失败，继续尝试...", "WARNING")
+        else:
+            self.log("未配置自动复位，等待手动复位...", "INFO")
+        
+        # 3. 尝试自动等待并发送boot2（200ms窗口期）
+        if self.reset_pin != 'none':
+            self.log("尝试在200ms窗口期内接收boot1信号...", "INFO")
+            if self.wait_for_boot1_signal_and_send_boot2(boot2_file):
+                self.log("boot1信号接收成功，已发送boot2程序", "INFO")
+            else:
+                self.log("200ms窗口期内未收到boot1信号，请手动复位", "WARNING")
+                
+                # 手动复位等待
+                if not self.wait_for_boot1_signal_blocking(boot2_file):
+                    self.log("等待被用户中断", "ERROR")
+                    return False
+        else:
+            # 直接等待手动复位
+            if not self.wait_for_boot1_signal_blocking(boot2_file):
+                self.log("等待被用户中断", "ERROR")
+                return False
+        
+        # 4. 等待100ms
+        time.sleep(0.1)
+        
+        # 5. 切换到128000bps并检查是否在boot2中
+        self.log("验证boot2程序...", "INFO")
+        self.close()
+        self.open(baudrate=BOOT2_BAUDRATE)
+        time.sleep(0.05)  # 额外等待50ms稳定
+        
+        if self.check_boot2():
+            self.log("boot2上传成功", "INFO")
+            return True
+        else:
+            self.log("boot2上传后验证失败", "ERROR")
+            return False
+    
+    def read_memory(self, addr: int, size: int) -> bytes:
+        """
+        读取内存
+        
+        Args:
+            addr: 起始地址
+            size: 读取大小
+            
+        Returns:
+            读取到的数据
+        """
+        if not self.in_boot2:
+            raise STM8BootloaderError("不在boot2模式中")
+        
+        result = bytearray()
+        remaining = size
+        current_addr = addr
+        
+        while remaining > 0:
+            chunk_size = min(remaining, MAX_DATA_SIZE)
+            
+            try:
+                # 发送读取命令，数据字段为要读取的长度
+                response = self.send_command(CMD_READ, current_addr, 
+                                           struct.pack('B', chunk_size))
+                
+                if not response:
+                    raise STM8BootloaderError(f"读取地址 0x{current_addr:04X} 失败")
+                
+                cmd, resp_addr, data = response
+                
+                if cmd != CMD_READ or resp_addr != current_addr:
+                    raise STM8BootloaderError(f"读取响应不匹配")
+                
+                if len(data) != chunk_size:
+                    raise STM8BootloaderError(f"读取长度不匹配: 期望{chunk_size}, 实际{len(data)}")
+                
+                result.extend(data)
+                remaining -= chunk_size
+                current_addr += chunk_size
+                
+                self.log(f"已读取 0x{current_addr-chunk_size:04X} - 0x{current_addr-1:04X} ({chunk_size}字节)", "DEBUG")
+                
+            except Exception as e:
+                raise STM8BootloaderError(f"读取过程中出错: {e}")
+        
+        return bytes(result)
+    
+    def write_memory(self, addr: int, data: bytes) -> bool:
+        """
+        写入内存
+        
+        Args:
+            addr: 起始地址
+            data: 要写入的数据
+            
+        Returns:
+            True: 写入成功, False: 写入失败
+        """
+        if not self.in_boot2:
+            raise STM8BootloaderError("不在boot2模式中")
+        
+        remaining = len(data)
+        current_addr = addr
+        offset = 0
+        
+        while remaining > 0:
+            chunk_size = min(remaining, MAX_DATA_SIZE)
+            chunk_data = data[offset:offset+chunk_size]
+            
+            try:
+                response = self.send_command(CMD_WRITE, current_addr, chunk_data)
+                
+                if not response:
+                    raise STM8BootloaderError(f"写入地址 0x{current_addr:04X} 失败")
+                
+                cmd, resp_addr, resp_data = response
+                
+                if cmd != CMD_WRITE or resp_addr != current_addr:
+                    raise STM8BootloaderError(f"写入响应不匹配")
+                
+                self.log(f"已写入 0x{current_addr:04X} - 0x{current_addr+chunk_size-1:04X} ({chunk_size}字节)", "DEBUG")
+                
+                remaining -= chunk_size
+                current_addr += chunk_size
+                offset += chunk_size
+                
+            except Exception as e:
+                raise STM8BootloaderError(f"写入过程中出错: {e}")
+        
+        return True
+    
+    def go_execute(self, addr: int) -> bool:
+        """
+        跳转到指定地址执行
+        
+        Args:
+            addr: 执行地址
+            
+        Returns:
+            True: 命令发送成功
+        """
+        if not self.in_boot2:
+            raise STM8BootloaderError("不在boot2模式中")
+        
+        try:
+            # go命令不需要等待响应
+            self.send_command(CMD_GO, addr, b'', wait_response=False)
+            self.log(f"已发送跳转到 0x{addr:04X} 的命令", "DEBUG")
+            return True
+        except Exception as e:
+            raise STM8BootloaderError(f"发送跳转命令失败: {e}")
+    
+    def get_info(self) -> dict:
+        """
+        获取MCU信息
+        
+        Returns:
+            包含MCU信息的字典
+        """
+        if not self.in_boot2:
+            raise STM8BootloaderError("不在boot2模式中")
+        
+        try:
+            data = self.read_memory(HANDSHAKE_ADDR, HANDSHAKE_SIZE)
+            
+            if len(data) < HANDSHAKE_SIZE:
+                raise STM8BootloaderError("信息数据长度不足")
+            
+            # 解析握手数据
+            boot0_addr = (data[1] << 8) | data[0]  # 注意字节序
+            main_addr = (data[7] << 8) | data[6]    # 注意字节序
+            
+            info = {
+                'boot0_address': boot0_addr,
+                'main_program_address': main_addr,
+                'raw_data': data.hex(' '),
+                'in_boot2': self.in_boot2
+            }
+            
+            return info
+            
+        except Exception as e:
+            raise STM8BootloaderError(f"获取信息失败: {e}")
+    
+    def interactive_mode(self):
+        """交互模式"""
+        self.log("\n=== STM8 Bootloader 交互模式 ===", "INFO")
+        self.log("可用命令: read, write, go, info, help, exit", "INFO")
+        self.log("输入 'help' 查看详细用法\n", "INFO")
+        
+        while True:
+            try:
+                cmd_input = input("stm8loader> ").strip()
+                if not cmd_input:
+                    continue
+                
+                args = cmd_input.split()
+                cmd = args[0].lower()
+                
+                if cmd == 'exit' or cmd == 'quit':
+                    self.log("退出交互模式", "INFO")
+                    break
+                    
+                elif cmd == 'help':
+                    self.show_help()
+                    
+                elif cmd == 'info':
+                    try:
+                        info = self.get_info()
+                        self.log("MCU信息:", "INFO")
+                        self.log(f"  Boot0启动地址: 0x{info['boot0_address']:04X}", "INFO")
+                        self.log(f"  主程序启动地址: 0x{info['main_program_address']:04X}", "INFO")
+                        self.log(f"  原始数据: {info['raw_data']}", "INFO")
+                        self.log(f"  当前模式: {'boot2' if info['in_boot2'] else '未知'}", "INFO")
+                    except Exception as e:
+                        self.log(f"错误: {e}", "ERROR")
+                        
+                elif cmd == 'read':
+                    if len(args) < 3:
+                        self.log("用法: read <addr> <size> [file]", "ERROR")
+                        continue
+                    
+                    try:
+                        addr = int(args[1], 0)
+                        size = int(args[2], 0)
+                        
+                        data = self.read_memory(addr, size)
+                        
+                        # 显示数据
+                        self.print_hex_dump(addr, data)
+                        
+                        # 保存到文件（如果指定）
+                        if len(args) >= 4:
+                            filename = args[3]
+                            with open(filename, 'wb') as f:
+                                f.write(data)
+                            self.log(f"数据已保存到 {filename}", "INFO")
+                            
+                    except Exception as e:
+                        self.log(f"错误: {e}", "ERROR")
+                        
+                elif cmd == 'write':
+                    if len(args) < 3:
+                        self.log("用法: write <addr> <file/hex_string>", "ERROR")
+                        self.log("示例: write 0x8000 firmware.bin", "INFO")
+                        self.log("示例: write 0x8000 AABBCCDDEEFF", "INFO")
+                        continue
+                    
+                    try:
+                        addr = int(args[1], 0)
+                        source = args[2]
+                        
+                        # 判断是文件还是hex字符串
+                        if os.path.exists(source):
+                            # 从文件读取
+                            with open(source, 'rb') as f:
+                                data = f.read()
+                        else:
+                            # 尝试解析为hex字符串
+                            source = source.replace('0x', '').replace(' ', '')
+                            if len(source) % 2 != 0:
+                                raise ValueError("Hex字符串长度必须是偶数")
+                            data = bytes.fromhex(source)
+                        
+                        if self.write_memory(addr, data):
+                            self.log(f"写入成功: {len(data)} 字节到 0x{addr:04X}", "INFO")
+                            
+                    except Exception as e:
+                        self.log(f"错误: {e}", "ERROR")
+                        
+                elif cmd == 'go':
+                    if len(args) < 2:
+                        self.log("用法: go <addr>", "ERROR")
+                        continue
+                    
+                    try:
+                        addr = int(args[1], 0)
+                        if self.go_execute(addr):
+                            self.log(f"已发送跳转到 0x{addr:04X} 的命令", "INFO")
+                    except Exception as e:
+                        self.log(f"错误: {e}", "ERROR")
+                        
+                else:
+                    self.log(f"未知命令: {cmd}", "ERROR")
+                    self.log("输入 'help' 查看可用命令", "INFO")
+                    
+            except KeyboardInterrupt:
+                self.log("\n退出交互模式", "INFO")
+                break
+            except Exception as e:
+                self.log(f"错误: {e}", "ERROR")
+    
+    def print_hex_dump(self, start_addr: int, data: bytes, bytes_per_line: int = 16):
+        """以hexdump格式打印数据"""
+        for i in range(0, len(data), bytes_per_line):
+            chunk = data[i:i+bytes_per_line]
+            hex_str = ' '.join(f'{b:02X}' for b in chunk)
+            ascii_str = ''.join(chr(b) if 32 <= b < 127 else '.' for b in chunk)
+            addr = start_addr + i
+            print(f"{addr:04X}: {hex_str:<48} {ascii_str}")
+    
+    @staticmethod
+    def show_help():
+        """显示帮助信息"""
+        help_text = """
+命令列表:
+  read <addr> <size> [file]    - 读取内存，可选保存到文件
+                                 示例: read 0x8000 256 dump.bin
+  
+  write <addr> <file/hex_str>  - 写入内存，支持文件或hex字符串
+                                 示例: write 0x8000 firmware.bin
+                                 示例: write 0x8000 AABBCCDDEEFF
+  
+  go <addr>                    - 跳转到指定地址执行
+                                 示例: go 0x8000
+  
+  info                         - 显示MCU信息
+  
+  help                         - 显示此帮助信息
+  
+  exit / quit                  - 退出交互模式
+        """
+        print(help_text)
+
+
+def list_serial_ports():
+    """列出可用串口"""
+    ports = list_ports.comports()
+    if not ports:
+        print("[INFO] 未找到可用串口")
+        return
+    
+    print("[INFO] 可用串口:")
+    for i, port in enumerate(ports):
+        print(f"  {i+1}. {port.device} - {port.description}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='STM8 Bootloader 交互工具',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+示例:
+  %(prog)s COM3                           # 进入交互模式
+  %(prog)s COM3 -r 0x8000 256             # 读取内存
+  %(prog)s COM3 -w 0x8000 firmware.bin    # 写入文件
+  %(prog)s COM3 -w 0x8000 "AABBCC"        # 写入hex字符串
+  %(prog)s COM3 -g 0x8000                 # 跳转执行
+  %(prog)s --list-ports                   # 列出可用串口
+        """
+    )
+    
+    # 串口相关参数
+    parser.add_argument('port', nargs='?', help='串口号 (如 COM3, /dev/ttyUSB0)')
+    parser.add_argument('-b', '--baudrate', type=int, default=BOOT2_BAUDRATE,
+                       help=f'串口波特率 (默认: {BOOT2_BAUDRATE})')
+    
+    # boot2上传参数
+    parser.add_argument('--boot2', default='boot2.bin',
+                       help='boot2程序文件路径 (默认: 脚本目录下的boot2.bin)')
+    
+    # 复位参数
+    parser.add_argument('--reset-pin', choices=['rts', 'dtr', 'none'], default='rts',
+                       help='复位引脚类型，none表示不自动复位 (默认: rts)')
+    
+    # 操作命令
+    parser.add_argument('-r', '--read', nargs=2, metavar=('ADDR', 'SIZE'),
+                       help='读取内存: ADDR为起始地址，SIZE为读取大小')
+    parser.add_argument('-w', '--write', nargs=2, metavar=('ADDR', 'FILE/HEX'),
+                       help='写入内存: ADDR为起始地址，FILE/HEX为文件或hex字符串')
+    parser.add_argument('-g', '--go', metavar='ADDR',
+                       help='跳转到地址执行')
+    
+    # 其他选项
+    parser.add_argument('--list-ports', action='store_true',
+                       help='列出可用串口')
+    parser.add_argument('-o', '--output',
+                       help='读取操作时保存到的文件')
+    parser.add_argument('-i', '--interactive', action='store_true',
+                       help='执行命令后进入交互模式')
+    parser.add_argument('-v', '--verbose', action='store_true',
+                       help='显示详细调试信息')
+    
+    args = parser.parse_args()
+    
+    # 列出串口
+    if args.list_ports:
+        list_serial_ports()
+        return
+    
+    # 检查串口参数
+    if not args.port:
+        print("[ERROR] 必须指定串口号")
+        print("[INFO] 使用 --list-ports 查看可用串口")
+        parser.print_help()
+        return 1
+    
+    try:
+        # 创建bootloader实例
+        loader = STM8Bootloader(args.port, verbose=args.verbose, reset_pin=args.reset_pin)
+        
+        # 打开串口
+        loader.open(baudrate=args.baudrate)
+        
+        # 检查是否已在boot2中
+        in_boot2 = loader.check_boot2()
+        
+        # 如果不在boot2中，则必须上传boot2
+        if not in_boot2:
+            print("[INFO] 不在boot2模式中，开始上传boot2程序...")
+            if not loader.upload_boot2(args.boot2):
+                print("[ERROR] boot2上传失败")
+                loader.close()
+                return 1
+            print("[INFO] boot2上传成功")
+        
+        # 执行命令行指定的操作
+        command_executed = False
+        
+        if args.read:
+            command_executed = True
+            try:
+                addr = int(args.read[0], 0)
+                size = int(args.read[1], 0)
+                
+                data = loader.read_memory(addr, size)
+                
+                # 打印数据
+                loader.print_hex_dump(addr, data)
+                
+                # 保存到文件（如果指定）
+                if args.output:
+                    with open(args.output, 'wb') as f:
+                        f.write(data)
+                    print(f"[INFO] 数据已保存到 {args.output}")
+                    
+            except Exception as e:
+                print(f"[ERROR] 读取失败: {e}")
+                loader.close()
+                return 1
+        
+        elif args.write:
+            command_executed = True
+            try:
+                addr = int(args.write[0], 0)
+                source = args.write[1]
+                
+                # 判断是文件还是hex字符串
+                if os.path.exists(source):
+                    # 从文件读取
+                    with open(source, 'rb') as f:
+                        data = f.read()
+                else:
+                    # 尝试解析为hex字符串
+                    source = source.replace('0x', '').replace(' ', '')
+                    if len(source) % 2 != 0:
+                        raise ValueError("Hex字符串长度必须是偶数")
+                    data = bytes.fromhex(source)
+                
+                if loader.write_memory(addr, data):
+                    print(f"[INFO] 写入成功: {len(data)} 字节到 0x{addr:04X}")
+                    
+            except Exception as e:
+                print(f"[ERROR] 写入失败: {e}")
+                loader.close()
+                return 1
+        
+        elif args.go:
+            command_executed = True
+            try:
+                addr = int(args.go, 0)
+                if loader.go_execute(addr):
+                    print(f"[INFO] 已发送跳转到 0x{addr:04X} 的命令")
+            except Exception as e:
+                print(f"[ERROR] 跳转失败: {e}")
+                loader.close()
+                return 1
+        
+        # 如果没有指定命令或需要进入交互模式
+        if not command_executed or args.interactive:
+            loader.interactive_mode()
+        
+        # 关闭串口
+        loader.close()
+        
+    except KeyboardInterrupt:
+        print("\n[INFO] 程序被用户中断")
+        return 1
+    except Exception as e:
+        print(f"[ERROR] 错误: {e}")
+        return 1
+    
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())