如何为MicroPython微控制器项目构建多运行模式类结构

问题 #

我正在开发一个采用MicroPython编程的微控制器项目，目前难以找到合理的方式扩展代码以支持多种运行模式。

当前代码结构如下：我定义了一个HardwareClass基类，用于初始化各类硬件接口并从配置文件加载信息；还有一个ApplicationClass类负责实现业务逻辑——拆分两者主要是为了避免代码过于臃肿。

class HardwareClass():
    def __init__(self):
        self.display = self.initialise_display()
        self.sensor = self.initialise_sensor()
        self.config = self.load_config_from_sd()

    # 其他硬件初始化方法...

class ApplicationClass(HardwareClass):
    def run(self):
        while True:
            # 执行业务逻辑
            pass

app = ApplicationClass()
app.run()

我希望实现测试模式和正常运行模式，通过配置文件中的值来选择模式。

我的初步想法是为每种模式编写不同的ApplicationClass子类——这样可以复用启动时初始化的所有硬件接口，且每个子类拥有不同的run()方法。但我无法直接提前实例化子类，因为只有加载完配置文件后，我才能确定需要使用哪个类。

我也曾考虑过为每种模式单独定义run()方法并在运行时导入，但这种方式存在问题，还会导致IDE无法识别不同run方法（或函数）中引用的有效类成员（即各类硬件组件）。

请问有什么合理的方案可以安排这类应用的结构？

解决方案 #

方案1：先初始化硬件加载配置，再动态绑定模式类 #

核心是拆分硬件初始化与模式实例化流程：先完成硬件配置加载，再基于配置选择对应的模式子类，复用已初始化的硬件属性。

class HardwareClass():
    def __init__(self):
        self.display = self.initialise_display()
        self.sensor = self.initialise_sensor()
        self.config = self.load_config_from_sd()

    # 示例硬件方法
    def initialise_display(self):
        # 实际初始化显示设备
        return MockDisplay()
    def initialise_sensor(self):
        # 实际初始化传感器
        return MockSensor()
    def load_config_from_sd(self):
        # 实际从SD卡读取配置，这里模拟返回
        return {"mode": "test"}

# 定义测试模式子类
class TestModeClass(HardwareClass):
    def run(self):
        print("进入测试模式")
        while True:
            sensor_val = self.sensor.read()
            self.display.show(f"传感器值：{sensor_val}")
            # 测试模式可添加退出逻辑，比如检测按键
            if self._check_test_exit():
                break

    def _check_test_exit(self):
        # 模拟退出检测
        return False

# 定义正常运行模式子类
class RunModeClass(HardwareClass):
    def run(self):
        print("进入正常运行模式")
        while True:
            sensor_val = self.sensor.read()
            self._process_sensor_data(sensor_val)
            self.display.update_status("运行中")

    def _process_sensor_data(self, val):
        # 模拟数据处理逻辑
        pass

# 模拟硬件类用于测试
class MockDisplay():
    def show(self, text):
        print(f"显示：{text}")
    def update_status(self, status):
        print(f"状态更新：{status}")

class MockSensor():
    def read(self):
        return 25.6

# 核心执行逻辑
if __name__ == "__main__":
    # 先初始化硬件，加载配置
    hardware = HardwareClass()
    target_mode = hardware.config.get("mode", "run")

    # 根据配置选择模式类，复用硬件实例的属性
    if target_mode == "test":
        app_instance = TestModeClass.__new__(TestModeClass)
    else:
        app_instance = RunModeClass.__new__(RunModeClass)
    
    # 将硬件实例的属性复制给模式实例，跳过子类__init__避免重复初始化
    app_instance.__dict__ = hardware.__dict__
    app_instance.run()

优势：

• 完全复用硬件初始化结果，避免重复操作硬件
• 模式类的run()方法可正常访问self.display、self.sensor等成员，IDE能正确识别
• 模式类定义清晰，符合面向对象继承逻辑

方案2：策略模式解耦硬件与模式逻辑 #

将不同模式的业务逻辑封装为独立策略类，硬件类作为上下文，运行时注入对应策略。

class HardwareClass():
    def __init__(self):
        self.display = self.initialise_display()
        self.sensor = self.initialise_sensor()
        self.config = self.load_config_from_sd()
        self._mode_strategy = None

    def set_mode_strategy(self, strategy):
        self._mode_strategy = strategy

    def run(self):
        if self._mode_strategy:
            self._mode_strategy.execute(self)

    # 硬件初始化方法同方案1...

# 测试模式策略
class TestModeStrategy():
    def execute(self, hardware):
        print("测试模式运行中")
        while True:
            val = hardware.sensor.read()
            hardware.display.show(f"测试读数：{val}")
            if hardware._check_test_exit():
                break

# 正常模式策略
class RunModeStrategy():
    def execute(self, hardware):
        print("正常模式运行中")
        while True:
            val = hardware.sensor.read()
            hardware._process_sensor_data(val)
            hardware.display.update_status("正常运行")

# 执行逻辑
if __name__ == "__main__":
    hardware = HardwareClass()
    target_mode = hardware.config.get("mode", "run")

    if target_mode == "test":
        hardware.set_mode_strategy(TestModeStrategy())
    else:
        hardware.set_mode_strategy(RunModeStrategy())

    hardware.run()

优势：

• 硬件逻辑与模式逻辑完全解耦，各自独立维护
• 新增模式仅需添加新策略类，无需修改硬件类
• 给hardware参数添加类型注解后，IDE可识别其成员

方案3：单类分支处理（适合模式较少场景） #

如果模式数量不多，可直接在ApplicationClass的run()方法中根据配置分支处理，结构最简洁。

class HardwareClass():
    def __init__(self):
        self.display = self.initialise_display()
        self.sensor = self.initialise_sensor()
        self.config = self.load_config_from_sd()

    # 硬件初始化方法同前...

class ApplicationClass(HardwareClass):
    def run(self):
        target_mode = self.config.get("mode", "run")
        if target_mode == "test":
            self._run_test_mode()
        else:
            self._run_normal_mode()

    def _run_test_mode(self):
        print("测试模式启动")
        while True:
            # 测试逻辑
            sensor_val = self.sensor.read()
            self.display.show(f"测试：{sensor_val}")

    def _run_normal_mode(self):
        print("正常模式启动")
        while True:
            # 正常业务逻辑
            sensor_val = self.sensor.read()
            self._process_data(sensor_val)

app = ApplicationClass()
app.run()

优势：代码结构简单，无需额外类定义；缺点：模式逻辑集中在一个类中，模式过多会导致类膨胀。

内容的提问来源于stack exchange，提问作者sandyscott