档案馆八防体系环境模块落地：温湿度监测与净化设备一体化集成

┌─────────────────────────────────────────────────────────────────────┐
│                    档案馆"八防"体系全景                             │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐            │
│  │   防火        │  │   防盗        │  │   防水        │            │
│  │  ·烟感        │  │  ·门禁        │  │  ·漏水检测    │            │
│  │  ·温升预警    │  │  ·红外        │  │  ·水位传感器  │            │
│  │  ·电气火灾    │  │  ·视频        │  │  ·水泵联动    │            │
│  └──────────────┘  └──────────────┘  └──────────────┘            │
│                                                                     │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐            │
│  │   防潮        │  │   防高温      │  │   防尘        │            │
│  │  ·湿度监测 ←──┼──┤·温度监测 ←──┼──┤·PM2.5/PM10   │            │
│  │  ·除湿机 ─────┼──┤·精密空调 ───┼──┤·净化设备 ────┼──┐         │
│  │  ·恒湿机      │  │  ·新风        │  │  ·新风过滤    │  │         │
│  └──────────────┘  └──────────────┘  └──────────────┘  │         │
│                                                         │         │
│  ┌──────────────┐                                      │         │
│  │ 防有害生物   │  ←────────────────────────────────────┘         │
│  │ ·CO₂/VOC     │  温湿度异常 → 霉变风险 → 触发净化/通风          │
│  │ ·臭氧        │  湿度>65%RH → 虫霉繁殖加速 → 启动除湿+净化      │
│  │ ·紫外        │  温度>28℃ → 害虫活跃 → 启动降温                │
│  └──────────────┘                                                 │
│                                                                     │
│  ┌───────────────────────────────────────────────────────────────┐ │
│  │          一体化集成平台（统一数据采集+联动控制）                │ │
│  │  · 环境监测子系统  · 设备控制子系统  · 告警联动子系统          │ │
│  │  · 数据分析子系统  · 可视化展示子系统  · 运维管理子系统        │ │
│  └───────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────┐
│                         档案馆一体化集成平台                        │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌────────────────────────────────────────────────────────────────┐│
│  │                      统一数据总线（MQTT/Redis）                  ││
│  └───────────────────────────┬────────────────────────────────────┘│
│                              │                                      │
│  ┌───────────────────────────▼────────────────────────────────────┐│
│  │                    环境感知层（数据采集）                        ││
│  ├─────────────┬─────────────┬──────────────┬────────────────────┤│
│  │ 温湿度传感器 │ PM2.5/PM10 │ CO₂/VOC      │ 漏水/烟感/红外     ││
│  │ (UDP+SNMP) │ (RS485)     │ (RS485)      │ (DI/干接点)        ││
│  │ POE供电    │ 激光散射     │ NDIR/半导体  │ 开关量             ││
│  └─────────────┴─────────────┴──────────────┴────────────────────┘│
│                                                                     │
│  ┌────────────────────────────────────────────────────────────────┐│
│  │                    设备执行层（联动控制）                        ││
│  ├─────────────┬─────────────┬──────────────┬────────────────────┤│
│  │ 精密空调    │ 除湿/加湿机 │ 空气净化器   │ 新风/排风系统     ││
│  │ (Modbus TCP)│ (Modbus TCP)│ (Modbus TCP) │ (DI/DO + Modbus)  ││
│  │ 制冷/制热   │ 恒湿        │ 过滤/杀菌    │ 换气/正压维持     ││
│  └─────────────┴─────────────┴──────────────┴────────────────────┘│
│                                                                     │
│  ┌────────────────────────────────────────────────────────────────┐│
│  │                    联动规则引擎（核心逻辑）                      ││
│  ├─────────────┬─────────────┬──────────────┬────────────────────┤│
│  │ 八防规则库  │ 阈值判定    │ 设备调度     │ 告警联动          ││
│  │ ·防潮规则  │ ·温湿度     │ ·轮值/互斥   │ ·声光/短信/平台   ││
│  │ ·防高温规则│ ·PM2.5      │ ·防抖/死区   │ ·工单自动生成     ││
│  │ ·防尘规则  │ ·CO₂        │ ·优先级      │ ·应急预案         ││
│  │ ·防虫霉规则│ ·多参数融合 │ ·故障切换    │ ·审计日志         ││
│  └─────────────┴─────────────┴──────────────┴────────────────────┘│
│                                                                     │
│  ┌────────────────────────────────────────────────────────────────┐│
│  │                    可视化与运维层                                ││
│  ├─────────────┬─────────────┬──────────────┬────────────────────┤│
│  │ 3D库房视图  │ 实时趋势    │ 八防评分     │ 运维管理          ││
│  │ 设备状态    │ 历史报表    │ 环境健康度   │ 巡检/校准/维保    ││
│  └─────────────┴─────────────┴──────────────┴────────────────────┘│
└─────────────────────────────────────────────────────────────────────┘

感知 → 判定 → 决策 → 执行 → 反馈 → 优化

1. 感知：温湿度传感器每5秒UDP上报 + SNMP每30秒轮询
2. 判定：多传感器融合，异常剔除，滤波去噪
3. 决策：联动规则引擎匹配八防规则，生成控制指令
4. 执行：Modbus TCP写入设备寄存器，启动/停止/调速
5. 反馈：设备状态回读确认，环境参数变化验证
6. 优化：历史数据分析，自动调整阈值和死区

规则编号：FP-01
规则名称：防潮-湿度超标联动除湿
触发条件：
  AND(湿度 > 60%RH, 持续时间 > 120s)
执行动作：
  1. 启动除湿机（按轮值策略选择）
  2. 关闭新风系统（防止室外湿气进入）
  3. 关闭排风系统
  4. 如果湿度 > 65%RH，同时启动净化设备（防霉变）
恢复条件：
  湿度 < 55%RH, 持续时间 > 300s
关联八防：防潮、防有害生物（高湿→霉变）

规则编号：FP-02
规则名称：防高温-温度超标联动制冷
触发条件：
  AND(温度 > 24℃, 持续时间 > 60s)
执行动作：
  1. 启动精密空调（制冷模式）
  2. 关闭外窗（如果有电动窗）
  3. 如果温度 > 26℃，启动备用空调
恢复条件：
  温度 < 23.5℃, 持续时间 > 180s
关联八防：防高温、防有害生物（高温→害虫活跃）

规则编号：FP-03
规则名称：防尘-PM2.5超标联动净化
触发条件：
  AND(PM2.5 > 75μg/m³, 持续时间 > 180s)
执行动作：
  1. 启动空气净化器（最高档）
  2. 关闭新风系统（如果室外PM2.5也高）
  3. 如果室外PM2.5 < 50μg/m³，启动新风+内循环净化
恢复条件：
  PM2.5 < 50μg/m³, 持续时间 > 300s
关联八防：防尘

规则编号：FP-04
规则名称：防虫霉-温湿度协同异常联动
触发条件：
  OR(
    AND(湿度 > 65%RH, 温度 > 25℃),    # 霉变高风险
    AND(湿度 > 60%RH, CO₂ > 1000ppm),  # 通风不良+高湿
    VOC > 0.5mg/m³                     # 有机物挥发（可能已有霉变）
  )
  持续时间 > 300s
执行动作：
  1. 启动除湿机（优先降低湿度到<55%RH）
  2. 启动净化设备（杀菌模式，如果有UV/臭氧）
  3. 启动新风系统（最大风量，换气）
  4. 发送告警通知（短信+平台+工单）
  5. 记录事件到审计日志
恢复条件：
  AND(湿度 < 55%RH, 温度 < 24℃, CO₂ < 800ppm)
  持续时间 > 600s
关联八防：防有害生物、防潮、防高温

规则编号：FP-05
规则名称：综合-八防环境健康度评分
算法：
  环境健康度 = w1*(1 - |T - T_target|/T_range) 
             + w2*(1 - |H - H_target|/H_range)
             + w3*(1 - PM2.5/PM2.5_max)
             + w4*(1 - CO2/CO2_max)
  权重：w1=0.3, w2=0.3, w3=0.2, w4=0.2
  评分：0~100分
  分级：≥90 优秀, 80~89 良好, 60~79 合格, <60 不合格
执行动作：
  评分 < 60 → 触发全面检查，启动所有可用设备
  评分 < 40 → 触发应急预案，通知负责人
关联八防：全部

"""
eight_protection_engine.py - 八防联动规则引擎
"""

import time
from enum import Enum
from dataclasses import dataclass, field
from typing import List, Dict, Callable, Optional
import threading

class RuleState(Enum):
    INACTIVE = "inactive"      # 未触发
    PENDING = "pending"        # 条件满足，等待持续时间
    ACTIVE = "active"          # 已触发，执行中
    RECOVERING = "recovering"  # 条件恢复，等待恢复持续时间
    SUPPRESSED = "suppressed"  # 被高优先级规则抑制

@dataclass
class Rule:
    rule_id: str
    name: str
    condition: Callable[[Dict], bool]    # 触发条件函数
    recovery_condition: Callable[[Dict], bool]  # 恢复条件函数
    actions: List[Callable[[], None]]    # 执行动作列表
    recovery_actions: List[Callable[[], None]]  # 恢复动作列表
    trigger_delay: float = 120.0         # 触发延迟（秒）
    recovery_delay: float = 300.0        # 恢复延迟（秒）
    priority: int = 5                    # 优先级（1最高）
    enabled: bool = True
    state: RuleState = RuleState.INACTIVE
    state_change_time: float = 0.0
    last_check_data: Dict = field(default_factory=dict)

class EightProtectionEngine:
    """
    八防联动规则引擎
    """
    
    def __init__(self):
        self.rules: Dict[str, Rule] = {}
        self.data_bus: Dict[str, float] = {}  # 统一数据总线
        self.lock = threading.RLock()
        self.running = False
        self.thread = None
    
    def register_rule(self, rule: Rule):
        """注册规则"""
        with self.lock:
            self.rules[rule.rule_id] = rule
    
    def update_data(self, data: Dict[str, float]):
        """更新数据总线"""
        with self.lock:
            self.data_bus.update(data)
    
    def start(self):
        """启动引擎"""
        self.running = True
        self.thread = threading.Thread(target=self._run_loop, daemon=True)
        self.thread.start()
    
    def stop(self):
        """停止引擎"""
        self.running = False
        if self.thread:
            self.thread.join(timeout=5)
    
    def _run_loop(self):
        """主循环"""
        while self.running:
            current_time = time.time()
            with self.lock:
                for rule in self.rules.values():
                    if not rule.enabled:
                        continue
                    self._evaluate_rule(rule, current_time)
            time.sleep(1.0)  # 每秒评估一次
    
    def _evaluate_rule(self, rule: Rule, current_time: float):
        """评估单条规则"""
        condition_met = rule.condition(self.data_bus)
        
        if rule.state == RuleState.INACTIVE:
            if condition_met:
                rule.state = RuleState.PENDING
                rule.state_change_time = current_time
                print(f"[{rule.rule_id}] 条件满足，等待 {rule.trigger_delay}s")
        
        elif rule.state == RuleState.PENDING:
            if not condition_met:
                rule.state = RuleState.INACTIVE
                print(f"[{rule.rule_id}] 条件消失，重置")
            elif current_time - rule.state_change_time >= rule.trigger_delay:
                # 检查是否被高优先级规则抑制
                if self._is_suppressed(rule):
                    rule.state = RuleState.SUPPRESSED
                else:
                    rule.state = RuleState.ACTIVE
                    print(f"[{rule.rule_id}] 触发！执行动作")
                    for action in rule.actions:
                        try:
                            action()
                        except Exception as e:
                            print(f"  动作执行失败: {e}")
        
        elif rule.state == RuleState.ACTIVE:
            if rule.recovery_condition(self.data_bus):
                rule.state = RuleState.RECOVERING
                rule.state_change_time = current_time
                print(f"[{rule.rule_id}] 条件恢复，等待 {rule.recovery_delay}s")
        
        elif rule.state == RuleState.RECOVERING:
            if not rule.recovery_condition(self.data_bus):
                rule.state = RuleState.ACTIVE  # 条件再次不满足，回到ACTIVE
                print(f"[{rule.rule_id}] 条件再次异常，取消恢复")
            elif current_time - rule.state_change_time >= rule.recovery_delay:
                rule.state = RuleState.INACTIVE
                print(f"[{rule.rule_id}] 恢复！执行恢复动作")
                for action in rule.recovery_actions:
                    try:
                        action()
                    except Exception as e:
                        print(f"  恢复动作执行失败: {e}")
        
        elif rule.state == RuleState.SUPPRESSED:
            if not self._is_suppressed(rule):
                rule.state = RuleState.PENDING
                rule.state_change_time = current_time
                print(f"[{rule.rule_id}] 抑制解除，重新等待")
    
    def _is_suppressed(self, rule: Rule) -> bool:
        """检查是否被高优先级规则抑制"""
        for other in self.rules.values():
            if other.rule_id == rule.rule_id:
                continue
            if other.state != RuleState.ACTIVE:
                continue
            if other.priority < rule.priority:
                # 高优先级规则正在运行，检查是否互斥
                if self._are_rules_mutex(rule.rule_id, other.rule_id):
                    return True
        return False
    
    def _are_rules_mutex(self, rule1: str, rule2: str) -> bool:
        """规则互斥表"""
        mutex_pairs = {
            ("FP-02", "FP-01"): True,  # 制冷和除湿可能冲突（除湿也制冷）
            # 可扩展更多互斥关系
        }
        key1 = (rule1, rule2)
        key2 = (rule2, rule1)
        return mutex_pairs.get(key1, False) or mutex_pairs.get(key2, False)
    
    def get_status(self) -> Dict:
        """获取所有规则状态"""
        with self.lock:
            return {
                rule_id: {
                    "name": rule.name,
                    "state": rule.state.value,
                    "priority": rule.priority
                }
                for rule_id, rule in self.rules.items()
            }


# ============ 规则定义示例 ============

def create_moisture_proof_rule(dehumidifier_start, dehumidifier_stop):
    """创建防潮规则"""
    return Rule(
        rule_id="FP-01",
        name="防潮-湿度超标联动除湿",
        condition=lambda d: d.get("humidity", 0) > 60.0,
        recovery_condition=lambda d: d.get("humidity", 100) < 55.0,
        actions=[dehumidifier_start],
        recovery_actions=[dehumidifier_stop],
        trigger_delay=120.0,
        recovery_delay=300.0,
        priority=2
    )

def create_heat_proof_rule(ac_start, ac_stop):
    """创建防高温规则"""
    return Rule(
        rule_id="FP-02",
        name="防高温-温度超标联动制冷",
        condition=lambda d: d.get("temperature", 0) > 24.0,
        recovery_condition=lambda d: d.get("temperature", 100) < 23.5,
        actions=[ac_start],
        recovery_actions=[ac_stop],
        trigger_delay=60.0,
        recovery_delay=180.0,
        priority=1
    )

def create_pest_mold_rule(dehumidifier_start, purifier_start, fresh_air_stop):
    """创建防虫霉规则"""
    return Rule(
        rule_id="FP-04",
        name="防虫霉-温湿度协同异常联动",
        condition=lambda d: (
            (d.get("humidity", 0) > 65.0 and d.get("temperature", 0) > 25.0)
            or (d.get("humidity", 0) > 60.0 and d.get("co2", 0) > 1000.0)
            or (d.get("voc", 0) > 0.5)
        ),
        recovery_condition=lambda d: (
            d.get("humidity", 100) < 55.0 
            and d.get("temperature", 100) < 24.0
            and d.get("co2", 0) < 800.0
        ),
        actions=[dehumidifier_start, purifier_start, fresh_air_stop],
        recovery_actions=[],  # 恢复由各自独立规则处理
        trigger_delay=300.0,
        recovery_delay=600.0,
        priority=3
    )


# ============ 使用示例 ============

if __name__ == "__main__":
    engine = EightProtectionEngine()
    
    # 模拟设备控制函数
    def start_dehumidifier():
        print("  >>> 启动除湿机")
    
    def stop_dehumidifier():
        print("  >>> 停止除湿机")
    
    def start_ac():
        print("  >>> 启动精密空调")
    
    def stop_ac():
        print("  >>> 停止精密空调")
    
    def start_purifier():
        print("  >>> 启动净化设备")
    
    def stop_fresh_air():
        print("  >>> 关闭新风系统")
    
    # 注册规则
    engine.register_rule(create_moisture_proof_rule(start_dehumidifier, stop_dehumidifier))
    engine.register_rule(create_heat_proof_rule(start_ac, stop_ac))
    engine.register_rule(create_pest_mold_rule(start_dehumidifier, start_purifier, stop_fresh_air))
    
    # 启动引擎
    engine.start()
    
    # 模拟数据变化
    print("\n=== 模拟场景：湿度逐渐升高 ===")
    test_data_sequence = [
        {"humidity": 50.0, "temperature": 22.0, "co2": 600.0, "voc": 0.1},
        {"humidity": 58.0, "temperature": 22.0, "co2": 600.0, "voc": 0.1},
        {"humidity": 62.0, "temperature": 22.0, "co2": 600.0, "voc": 0.1},  # 超标
        {"humidity": 63.0, "temperature": 22.0, "co2": 600.0, "voc": 0.1},  # 持续
        {"humidity": 64.0, "temperature": 22.0, "co2": 600.0, "voc": 0.1},  # 持续
        {"humidity": 54.0, "temperature": 22.0, "co2": 600.0, "voc": 0.1},  # 恢复
        {"humidity": 53.0, "temperature": 22.0, "co2": 600.0, "voc": 0.1},  # 持续恢复
    ]
    
    for i, data in enumerate(test_data_sequence):
        print(f"\n--- 第{i+1}步: 湿度={data['humidity']}%RH ---")
        engine.update_data(data)
        time.sleep(1.5)  # 加速演示，实际中每秒自动评估
    
    engine.stop()

"""
device_abstraction.py - 设备抽象模型
"""

from abc import ABC, abstractmethod
from enum import Enum
from typing import Dict, Any

class DeviceType(Enum):
    AC = "ac"                    # 精密空调
    DEHUMIDIFIER = "dehumidifier" # 除湿机
    HUMIDIFIER = "humidifier"     # 加湿机
    PURIFIER = "purifier"         # 净化器
    FRESH_AIR = "fresh_air"       # 新风系统
    VALVE = "valve"               # 电动阀门

class DeviceState(Enum):
    OFF = 0
    ON = 1
    FAULT = 2
    UNKNOWN = 3

class BaseDevice(ABC):
    """
    设备抽象基类
    """
    
    def __init__(self, device_id: str, name: str, device_type: DeviceType):
        self.device_id = device_id
        self.name = name
        self.device_type = device_type
        self.state = DeviceState.UNKNOWN
        self.last_heartbeat = 0
        self.run_time_total = 0
        self.error_count = 0
    
    @abstractmethod
    def start(self, **kwargs) -> bool:
        """启动设备"""
        pass
    
    @abstractmethod
    def stop(self) -> bool:
        """停止设备"""
        pass
    
    @abstractmethod
    def get_status(self) -> Dict[str, Any]:
        """获取设备状态"""
        pass
    
    @abstractmethod
    def set_parameter(self, param: str, value: Any) -> bool:
        """设置设备参数"""
        pass


class ModbusDevice(BaseDevice):
    """
    Modbus TCP 设备基类
    """
    
    def __init__(self, device_id: str, name: str, device_type: DeviceType,
                 ip: str, port: int = 502, slave_id: int = 1):
        super().__init__(device_id, name, device_type)
        self.ip = ip
        self.port = port
        self.slave_id = slave_id
        self.client = None  # ModbusClient实例
    
    def connect(self) -> bool:
        """建立连接"""
        # 实际实现中使用 pymodbus 等库
        pass
    
    def disconnect(self):
        """断开连接"""
        if self.client:
            self.client.close()
    
    def read_register(self, address: int, count: int = 1) -> list:
        """读取寄存器"""
        pass
    
    def write_register(self, address: int, value: int) -> bool:
        """写入寄存器"""
        pass


class PrecisionAC(ModbusDevice):
    """
    精密空调设备
    """
    
    def __init__(self, device_id: str, name: str, ip: str, slave_id: int = 1):
        super().__init__(device_id, name, DeviceType.AC, ip, 502, slave_id)
        # 寄存器映射（示例，实际需根据设备手册）
        self.reg_map = {
            "control": 40001,      # 控制寄存器：0=停止, 1=启动
            "mode": 40002,         # 模式：0=制冷, 1=制热, 2=除湿, 3=送风
            "setpoint_temp": 40003,# 设定温度（×10）
            "setpoint_hum": 40004, # 设定湿度（×10）
            "fan_speed": 40005,    # 风速：0=自动, 1=低, 2=中, 3=高
            "status": 30001,       # 状态：0=停止, 1=运行, 2=故障
            "alarm": 30002,        # 告警码
            "return_temp": 30003,  # 回风温度（×10）
            "return_hum": 30004,   # 回风湿度（×10）
        }
    
    def start(self, **kwargs) -> bool:
        mode = kwargs.get("mode", 0)  # 默认制冷
        temp = kwargs.get("temperature", 230)  # 默认23.0℃
        hum = kwargs.get("humidity", 500)      # 默认50.0%
        
        try:
            self.write_register(self.reg_map["mode"], mode)
            self.write_register(self.reg_map["setpoint_temp"], temp)
            self.write_register(self.reg_map["setpoint_hum"], hum)
            self.write_register(self.reg_map["control"], 1)
            self.state = DeviceState.ON
            return True
        except Exception as e:
            print(f"[{self.name}] 启动失败: {e}")
            self.error_count += 1
            return False
    
    def stop(self) -> bool:
        try:
            self.write_register(self.reg_map["control"], 0)
            self.state = DeviceState.OFF
            return True
        except Exception as e:
            print(f"[{self.name}] 停止失败: {e}")
            return False
    
    def get_status(self) -> Dict[str, Any]:
        try:
            status = self.read_register(self.reg_map["status"], 1)[0]
            alarm = self.read_register(self.reg_map["alarm"], 1)[0]
            ret_temp = self.read_register(self.reg_map["return_temp"], 1)[0] / 10.0
            ret_hum = self.read_register(self.reg_map["return_hum"], 1)[0] / 10.0
            
            return {
                "device_id": self.device_id,
                "name": self.name,
                "state": status,
                "alarm": alarm,
                "return_temp": ret_temp,
                "return_hum": ret_hum
            }
        except Exception as e:
            return {"device_id": self.device_id, "state": "error", "message": str(e)}
    
    def set_parameter(self, param: str, value: Any) -> bool:
        reg_addr = self.reg_map.get(param)
        if not reg_addr:
            return False
        try:
            self.write_register(reg_addr, int(value))
            return True
        except Exception:
            return False


class Dehumidifier(ModbusDevice):
    """
    除湿机设备
    """
    
    def __init__(self, device_id: str, name: str, ip: str, slave_id: int = 1):
        super().__init__(device_id, name, DeviceType.DEHUMIDIFIER, ip, 502, slave_id)
        self.reg_map = {
            "control": 40001,
            "setpoint_hum": 40002,
            "fan_speed": 40003,
            "status": 30001,
            "current_hum": 30002,
            "tank_full": 30003,  # 水箱满告警
        }
    
    def start(self, **kwargs) -> bool:
        target_hum = kwargs.get("target_humidity", 50)
        try:
            self.write_register(self.reg_map["setpoint_hum"], target_hum * 10)
            self.write_register(self.reg_map["control"], 1)
            self.state = DeviceState.ON
            return True
        except Exception as e:
            print(f"[{self.name}] 启动失败: {e}")
            return False
    
    def stop(self) -> bool:
        try:
            self.write_register(self.reg_map["control"], 0)
            self.state = DeviceState.OFF
            return True
        except Exception:
            return False
    
    def get_status(self) -> Dict[str, Any]:
        try:
            status = self.read_register(self.reg_map["status"], 1)[0]
            hum = self.read_register(self.reg_map["current_hum"], 1)[0] / 10.0
            tank_full = self.read_register(self.reg_map["tank_full"], 1)[0]
            return {
                "device_id": self.device_id,
                "name": self.name,
                "state": status,
                "current_humidity": hum,
                "tank_full": bool(tank_full)
            }
        except Exception as e:
            return {"device_id": self.device_id, "state": "error", "message": str(e)}
    
    def set_parameter(self, param: str, value: Any) -> bool:
        reg_addr = self.reg_map.get(param)
        if not reg_addr:
            return False
        try:
            self.write_register(reg_addr, int(value))
            return True
        except Exception:
            return False

┌─────────────────────────────────────────────────────────────────────┐
│  档案馆八防环境健康度仪表盘                                         │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌───────────────────────────────────────────────────────────────┐ │
│  │  八防综合评分：85分（良好）                                     │ │
│  │  ████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ │ │
│  │  防火: ✓  防盗: ✓  防潮: ✓  防高温: ✓  防光: ✓               │ │
│  │  防尘: ⚠ (PM2.5偏高)  防虫霉: ✓  防水: ✓                     │ │
│  └───────────────────────────────────────────────────────────────┘ │
│                                                                     │
│  ┌───────────────────────┐  ┌───────────────────────────────────┐ │
│  │  实时环境参数          │  │  设备运行状态                      │ │
│  │  温度: 23.2℃ ✓       │  │  精密空调-01: 🟢运行 (制冷)       │ │
│  │  湿度: 54.8%RH ✓     │  │  精密空调-02: ⚪待机              │ │
│  │  PM2.5: 68μg/m³ ⚠   │  │  除湿机-01: 🟢运行               │ │
│  │  CO₂: 720ppm ✓       │  │  净化器-01: 🟢运行 (中速)        │ │
│  │  VOC: 0.12mg/m³ ✓    │  │  新风系统: 🟢运行 (30%)          │ │
│  └───────────────────────┘  └───────────────────────────────────┘ │
│                                                                     │
│  ┌───────────────────────────────────────────────────────────────┐ │
│  │  联动规则状态                                                   │ │
│  │  FP-01 防潮: 🟢 正常 (湿度54.8%, 未触发)                      │ │
│  │  FP-02 防高温: 🟢 正常 (温度23.2℃, 未触发)                   │ │
│  │  FP-03 防尘: 🟡 待恢复 (PM2.5 68μg/m³, 等待<50持续300s)      │ │
│  │  FP-04 防虫霉: 🟢 正常                                       │ │
│  │  FP-05 综合: 🟢 良好 (评分85)                                 │ │
│  └───────────────────────────────────────────────────────────────┘ │
│                                                                     │
│  ┌───────────────────────────────────────────────────────────────┐ │
│  │  今日事件日志                                                   │ │
│  │  08:23  FP-03 防尘规则触发 (PM2.5=78μg/m³)                    │ │
│  │  08:24  净化器-01 启动 (中速)                                  │ │
│  │  08:25  新风系统 切换为内循环                                  │ │
│  │  11:45  FP-03 防尘规则恢复 (PM2.5=45μg/m³)                    │ │
│  │  11:46  净化器-01 切换为低速                                  │ │
│  └───────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘