【花雕动手做】CanMV K230 AI视觉识别模块之使用WDT看门狗 简单

#【花雕动手做】CanMV K230 AI视觉识别模块之使用WDT看门狗      
# 项目功能：演示看门狗定时器的使用，包括初始化、喂狗和超时重启机制

# 导入必要的模块 | Import required modules
from machine import WDT  # 导入看门狗模块 | Import watchdog module
import time  # 导入时间模块 | Import time module

"""
详细解析 | Detailed Analysis:
WDT (Watchdog Timer) 是一种硬件定时器，如果在规定时间内没有被复位（喂狗），
系统就会自动重启。主要用于检测和恢复系统故障。

WDT is a hardware timer that will automatically restart the system if not reset
("fed") within a specified time. It's mainly used for detecting and recovering
from system failures.

技术要点 | Technical Points:
1. 工作原理：看门狗是一个递减计数器，从超时值开始递减到0
2. 喂狗操作：将计数器重置为初始超时值
3. 超时后果：系统强制重启，恢复系统到已知状态
4. 应用场景：防止程序死锁、检测任务阻塞、提高系统可靠性
"""

def init_watchdog(id=1, timeout=3):
    """初始化看门狗 | Initialize watchdog
    Args:
        id: 看门狗ID | Watchdog ID (通常为0或1，取决于硬件平台)
        timeout: 超时时间(秒) | Timeout period(seconds)
    Returns:
        WDT对象 | WDT object

    详细解析 | Analysis:
    创建WDT对象，设置超时时间。如果超过timeout秒没有喂狗，系统将重启。
    Creates WDT object and sets timeout. System will restart if not fed within timeout seconds.
    
    参数范围 | Parameter Ranges:
    - id: 看门狗实例编号，K230通常支持多个看门狗实例
    - timeout: 超时时间，通常有最小和最大限制（如0.5秒到30秒）
    """
    try:
        # 创建看门狗实例
        # 参数说明：
        # - id: 看门狗硬件外设编号
        # - timeout: 超时时间，单位秒
        wdt = WDT(id, timeout)
        print(f"看门狗初始化成功 | Watchdog initialized: ID={id}, 超时时间={timeout}秒 | timeout={timeout}s")
        return wdt
    except Exception as e:
        print(f"看门狗初始化失败 | Watchdog initialization failed: {e}")
        return None

def feed_watchdog(wdt, feed_times=3, interval=1):
    """定时喂狗 | Feed watchdog periodically
    Args:
        wdt: 看门狗对象 | Watchdog object
        feed_times: 喂狗次数 | Number of feeds
        interval: 喂狗间隔(秒) | Interval between feeds(seconds)

    详细解析 | Analysis:
    按照指定间隔喂狗指定次数。这个过程会持续 feed_times * interval 秒。
    Feeds the watchdog specified times at given intervals. This process will last
    for feed_times * interval seconds.
    
    设计考虑 | Design Considerations:
    1. 喂狗间隔应小于看门狗超时时间，确保不会意外触发重启
    2. 喂狗次数和间隔应根据实际应用场景调整
    3. 异常处理确保喂狗失败不会导致程序崩溃
    """
    if not wdt:
        print("看门狗对象无效，跳过喂狗 | Invalid watchdog object, skipping feed")
        return

    try:
        for i in range(feed_times):
            # 等待指定间隔时间
            # 在实际应用中，这里可以执行其他任务
            time.sleep(interval)
            
            # 执行喂狗操作，重置看门狗计数器
            wdt.feed()  # 喂狗操作 | Feed the watchdog
            
            print(f"第{i+1}次喂狗 | Feed watchdog {i+1} times")
            print(f"  下次喂狗在{interval}秒后 | Next feed in {interval} seconds")
            
    except Exception as e:
        print(f"喂狗过程出错 | Error during feeding: {e}")
        # 注意：喂狗失败可能导致系统重启

def main():
    """主函数 | Main function

    详细解析 | Analysis:
    程序的主要执行流程：
    1. 初始化看门狗
    2. 执行定时喂狗
    3. 停止喂狗等待系统重启

    Main program flow:
    1. Initialize watchdog
    2. Perform periodic feeding
    3. Stop feeding and wait for system restart
    
    演示场景 | Demonstration Scenario:
    这个示例演示了正常喂狗和停止喂狗两种情况：
    - 前3秒：正常喂狗，系统不会重启
    - 3秒后：停止喂狗，等待看门狗超时重启
    """
    print("=== 看门狗演示程序开始 ===")
    print("=== Watchdog Demo Started ===")
    
    # 初始化看门狗 | Initialize watchdog
    # 设置3秒超时，意味着如果3秒内不喂狗，系统将重启
    wdt = init_watchdog(timeout=3)
    if not wdt:
        print("程序退出 | Program exiting")
        return

    print("\n--- 开始喂狗周期 ---")
    print("--- Starting Feeding Cycle ---")
    
    # 喂狗循环 | Feeding loop
    # 参数说明：
    # - wdt: 看门狗对象
    # - feed_times=3: 喂狗3次
    # - interval=1: 每次间隔1秒
    # 总喂狗时间：3次 × 1秒 = 3秒，刚好在超时时间内
    feed_watchdog(wdt, feed_times=3, interval=1)

    # 等待重启 | Wait for restart
    print("\n--- 停止喂狗，等待看门狗超时重启 ---")
    print("--- Stopping feeding, waiting for watchdog timeout restart ---")
    print("系统将在3秒内重启... | System will restart within 3 seconds...")
    
    # 进入死循环，不再喂狗
    # 看门狗将在3秒超时后强制重启系统
    count = 0
    while True:
        time.sleep(0.1)  # 降低CPU占用 | Reduce CPU usage
        count += 1
        if count % 10 == 0:  # 每1秒打印一次
            print(f"等待重启... 已等待 {count/10} 秒 | Waiting for restart... {count/10}s elapsed")
            
        # 注意：在实际应用中，这里可能会有其他代码
        # 但由于没有喂狗，看门狗最终会超时重启系统

if __name__ == '__main__':
    main()

"""
=== 看门狗使用最佳实践 ===

1. 超时时间选择：
   - 实时性要求高的系统：1-3秒
   - 一般应用：5-10秒
   - 长任务处理：根据最长任务时间适当延长

2. 喂狗策略：
   - 在主循环中定期喂狗
   - 在关键任务完成后喂狗
   - 使用多个喂狗点提高可靠性

3. 错误处理：
   - 喂狗操作应包含异常处理
   - 记录看门狗重启事件用于诊断
   - 考虑在重启前保存关键数据

4. 应用场景：
   - 工业控制系统
   - 自动驾驶系统
   - 网络设备
   - 任何需要高可靠性的嵌入式系统

=== 预期执行结果 ===
1. 程序启动，初始化看门狗（3秒超时）
2. 前3秒：每秒喂狗一次，共3次
3. 第3秒后：停止喂狗，进入等待循环
4. 第6秒左右（从开始计算）：看门狗超时，系统自动重启

注意：实际重启时间可能因系统负载略有差异。
"""