程序代码篇---多循环串口程序切换

上位机版（Python）

要实现根据串口接收结果高效切换四个 while 循环函数，我们可以采用状态机模式，配合非阻塞串口读取来设计程序结构。这种方式可以实现快速切换，避免不必要的资源消耗。

下面是一个高效的实现方案，使用状态变量控制当前执行的循环，并通过非阻塞方式检查串口数据：

import serial
import time
import threading
from enum import Enum# 定义状态枚举，清晰表示四个不同状态
class State(Enum):STATE_1 = 1STATE_2 = 2STATE_3 = 3STATE_4 = 4class SerialStateMachine:def __init__(self, port='COM3', baudrate=9600, timeout=0.1):# 初始化串口self.ser = serial.Serial(port, baudrate, timeout=timeout)self.current_state = State.STATE_1  # 默认初始状态self.running = True  # 程序运行标志self.lock = threading.Lock()  # 线程锁，确保状态切换安全# 启动串口监听线程self.serial_thread = threading.Thread(target=self._serial_listener, daemon=True)self.serial_thread.start()def _serial_listener(self):"""串口监听线程，非阻塞读取指令"""while self.running:if self.ser.in_waiting > 0:# 读取并处理串口数据command = self.ser.readline().decode().strip()self._process_command(command)time.sleep(0.01)  # 短暂休眠，降低CPU占用def _process_command(self, command):"""处理接收到的命令，切换状态"""command_map = {'1': State.STATE_1,'2': State.STATE_2,'3': State.STATE_3,'4': State.STATE_4,'exit': None  # 退出程序}new_state = command_map.get(command)if new_state is None and command == 'exit':self.running = Falseprint("收到退出指令，程序将终止")elif new_state:with self.lock:self.current_state = new_stateprint(f"切换到状态: {new_state}")def state_1_loop(self):"""第一个循环函数"""start_time = time.time()while True:# 检查是否需要切换状态with self.lock:if self.current_state != State.STATE_1:return# 状态1的业务逻辑elapsed = time.time() - start_timeprint(f"状态1运行中 - {elapsed:.2f}秒", end='\r')# 控制循环频率，避免CPU占用过高time.sleep(0.1)def state_2_loop(self):"""第二个循环函数"""start_time = time.time()while True:with self.lock:if self.current_state != State.STATE_2:return# 状态2的业务逻辑elapsed = time.time() - start_timeprint(f"状态2运行中 - {elapsed:.2f}秒", end='\r')time.sleep(0.1)def state_3_loop(self):"""第三个循环函数"""start_time = time.time()while True:with self.lock:if self.current_state != State.STATE_3:return# 状态3的业务逻辑elapsed = time.time() - start_timeprint(f"状态3运行中 - {elapsed:.2f}秒", end='\r')time.sleep(0.1)def state_4_loop(self):"""第四个循环函数"""start_time = time.time()while True:with self.lock:if self.current_state != State.STATE_4:return# 状态4的业务逻辑elapsed = time.time() - start_timeprint(f"状态4运行中 - {elapsed:.2f}秒", end='\r')time.sleep(0.1)def run(self):"""主运行函数，根据当前状态执行相应循环"""state_mapping = {State.STATE_1: self.state_1_loop,State.STATE_2: self.state_2_loop,State.STATE_3: self.state_3_loop,State.STATE_4: self.state_4_loop}print("程序启动，等待串口指令...")print("发送 1-4 切换状态，发送 exit 退出程序")while self.running:# 获取当前状态对应的函数并执行current_func = state_mapping.get(self.current_state)if current_func:current_func()time.sleep(0.05)# 清理资源self.ser.close()print("\n程序已退出")if __name__ == "__main__":try:# 根据实际情况修改串口参数machine = SerialStateMachine(port='COM3', baudrate=9600)machine.run()except serial.SerialException as e:print(f"串口错误: {e}")except KeyboardInterrupt:print("\n用户中断程序")

这个程序结构的高效性体现在以下几个方面：

独立串口监听线程：使用单独的线程处理串口数据接收，避免阻塞主循环，确保指令能被及时处理。
状态机设计：通过枚举类型明确定义四个状态，使状态切换逻辑清晰，易于维护和扩展。
非阻塞检查：每个循环函数内部定期检查状态是否变化，一旦收到切换指令能立即退出当前循环，切换到新状态。
线程安全：使用线程锁保证状态变量的线程安全访问，避免多线程操作导致的状态不一致。
资源控制：每个循环都有适当的休眠时间，避免 CPU 占用过高。

使用时，只需通过串口发送 "1"、"2"、"3"、"4" 即可切换到相应的循环，发送 "exit" 则退出程序。你可以根据实际需求，在四个状态循环函数中实现具体的业务逻辑。

Openmv版（MincroPython）

在 OpenMV 上提升代码逻辑的运行反应速度，需要结合其硬件特性（基于 MicroPython，资源有限，主打机器视觉）和应用场景（状态切换、串口通信、实时处理）进行针对性优化。以下是具体的优化方向和实现方法：

一、代码结构优化：减少冗余与阻塞

OpenMV 的 CPU 性能有限（如 H7 型号为 480MHz，但 MicroPython 解释执行效率低于原生 C），需避免冗余计算和长时间阻塞。

1. 简化状态切换逻辑，减少检查开销

原状态机中若使用threading.Lock等线程同步机制，会引入额外开销。OpenMV 的线程支持较弱（无真正多线程，仅为分时调度），可改用轻量状态变量 + 非阻塞检查。
示例：用全局变量直接存储状态（无需锁），在循环中快速检查状态是否变化（避免复杂的上下文切换）。

import time
from pyb import UART# 状态定义（用整数代替Enum，减少属性查找开销）
STATE_1 = 1
STATE_2 = 2
STATE_3 = 3
STATE_4 = 4
current_state = STATE_1# 串口初始化（非阻塞模式）
uart = UART(3, 115200)  # 根据实际引脚配置
uart.init(115200, timeout_char=10)  # 缩短超时时间，快速返回def check_serial():"""非阻塞读取串口指令，直接修改全局状态"""global current_stateif uart.any():  # 检查是否有数据（比in_waiting更高效）cmd = uart.readline().strip().decode()if cmd == '1':current_state = STATE_1elif cmd == '2':current_state = STATE_2# ... 其他状态def state_1():while current_state == STATE_1:# 业务逻辑（避免复杂计算）check_serial()  # 循环内快速检查串口time.sleep_ms(10)  # 短延迟，平衡响应速度与CPU占用# 主循环
while True:if current_state == STATE_1:state_1()elif current_state == STATE_2:state_2()# ... 其他状态

2. 避免嵌套循环与深层调用

嵌套循环会增加栈开销和条件判断时间，尽量将逻辑扁平化。
减少函数调用层级：OpenMV 的函数调用开销较高，核心逻辑可适当 “内联”（避免频繁调用小函数）。

二、硬件资源优化：利用 OpenMV 专属特性

1. 优化串口通信效率

降低波特率：若无需高速通信，可将波特率从 115200 降至 9600（减少误码率和处理时间）。
固定指令格式：用单字节指令（如b'1'代替字符串'1'），避免复杂的字符串解析（decode()、strip()耗时）。

# 优化：直接处理字节，避免字符串转换
def check_serial_fast():global current_stateif uart.any():cmd = uart.read(1)  # 读取1字节指令if cmd == b'1':current_state = STATE_1elif cmd == b'2':current_state = STATE_2

使用中断接收：OpenMV 的 UART 支持中断（uart.irq()），可在数据到达时立即触发处理，避免循环中轮询的开销。

def uart_irq_handler(uart):global current_statecmd = uart.read(1)if cmd == b'1':current_state = STATE_1# ...# 注册中断
uart.irq(handler=uart_irq_handler, trigger=UART.IRQ_RXNE)  # 接收非空时触发

2. 控制循环延迟，平衡响应与性能

原代码中time.sleep(0.1)（100ms）可能导致响应滞后，可缩短至time.sleep_ms(10)（10ms），但需避免过度缩短（导致 CPU 占用过高，反而卡顿）。
用pyb.millis()（毫秒级定时器）替代time.time()，减少时间获取的开销（time.time()返回浮点数，计算耗时）。

# 优化：用毫秒计时，减少计算开销
def state_1():start_ms = pyb.millis()while current_state == STATE_1:elapsed = pyb.millis() - start_ms# ... 业务逻辑time.sleep_ms(10)  # 10ms延迟，响应更快

三、内存管理：减少 GC（垃圾回收）干扰

OpenMV 的内存较小（如 H7 为 32MB），频繁的内存分配会触发 GC，导致卡顿。

1. 预分配内存，避免动态创建对象

循环中避免频繁创建列表、字符串等对象，提前定义并复用。

# 优化前：每次循环创建新字符串
while True:print(f"状态1运行中: {elapsed}ms")  # f-string会动态创建字符串# 优化后：复用缓冲区
buf = bytearray(32)  # 预分配缓冲区
while True:# 用sprintf格式化到缓冲区（C风格，更快）buf[:] = b''  # 清空pyb.uart_write_str(uart, "状态1: %dms\n" % elapsed)  # 避免字符串拼接

2. 禁用自动 GC，手动触发

自动 GC 会在内存不足时突然执行，导致卡顿。可禁用自动 GC，在空闲时手动触发。

import gcgc.disable()  # 禁用自动垃圾回收def state_1():while current_state == STATE_1:# ... 业务逻辑if pyb.millis() % 1000 == 0:  # 每1秒手动回收一次gc.collect()

四、固件与工具链优化

1. 使用最新固件

OpenMV 官方会持续优化固件（如提升 MicroPython 执行效率、修复硬件驱动 bug），最新固件通常比旧版本运行更快。

烧录方法：通过 OpenMV IDE 的「Tools → Install Firmware」直接升级（确保型号匹配）。

2. 开启代码编译优化

OpenMV IDE 支持将 Python 代码编译为字节码（.mpy），执行速度比纯脚本（.py）快 30% 以上。
操作：「Tools → Save as .mpy」将main.py编译为main.mpy，放入 SD 卡（OpenMV 会优先执行.mpy）。

五、避免耗时操作阻塞主循环

1. 减少打印输出

print()会通过 USB 串口传输数据，速度慢且阻塞执行。调试完成后应删除冗余打印，或用条件编译关闭。

DEBUG = False  # 发布时设为Falseif DEBUG:print("调试信息")  # 仅调试时输出

2. 分离耗时任务（如图像处理）

若涉及摄像头图像处理，尽量使用 OpenMV 内置的 C 实现函数（如img.find_blobs()），避免用纯 Python 处理像素（速度极慢）。
将图像处理与状态切换分离：在单独的短周期内处理图像，结果存入全局变量，状态循环仅读取结果（不直接处理）。

总结：关键优化点

简化状态逻辑：用全局变量 + 轻量检查替代线程和锁。
优化串口：用中断接收 + 字节指令，减少解析开销。
控制延迟：缩短sleep时间至 10-50ms，平衡响应与性能。
内存管理：预分配对象 + 手动 GC，避免卡顿。
利用硬件特性：用内置函数（C 实现）、编译.mpy文件。

通过以上方法，可显著提升 OpenMV 代码的响应速度，尤其适合需要快速切换状态的串口控制场景。