{
              "steam_system": {
                "sensor_id": "steam_001",
                "location": "鍋爐出口",
                "unit": "MPa",
                "normal_range": [0.1, 0.3],
                "alerts": {
                  "low_pressure": {
                    "threshold": 0.08,
                    "message": "蒸汽壓力過低，加熱效率下降",
                    "action": "發送通知到廚師"
                  },
                  "high_pressure": {
                    "threshold": 0.35,
                    "message": "蒸汽壓力過高，存在安全風險",
                    "action": "立即觸發警報，通知設備維護員"
                  },
                  "critical": {
                    "threshold": 0.4,
                    "message": "蒸汽壓力臨界危險",
                    "action": "自動關閉進氣閥，通知消防隊"
                  }
                },
                "log_interval_seconds": 60
              }
            }

#!/usr/bin/env python3
            # -*- coding: utf-8 -*-
            """
            School Kitchen Temperature Monitoring System
            適用於 Raspberry Pi + ADS1256 A/D 轉換器
            """
            import time
            import json
            import os
            from datetime import datetime
            from decimal import Decimal
            import RPi.GPIO as GPIO
            import sqlite3
            import requests
            from threading import Thread
            import logging
            # ============= 配置段 =============
            CONFIG = {
                "db_path": "/var/lib/temperature_monitor/data.db",
                "log_path": "/var/log/temperature_monitor/",
                "update_interval": 60,  # 采樣間隔 (秒)
                "sensors": {
                    "cold_storage_1": {"channel": 0, "name": "冷藏櫃 #1", "unit": "°C", "min": 0, "max": 5},
                    "cold_storage_2": {"channel": 1, "name": "冷藏櫃 #2", "unit": "°C", "min": 0, "max": 5},
                    "cooking_area": {"channel": 2, "name": "蒸煮區", "unit": "°C", "min": 63, "max": 85},
                    "warming_area": {"channel": 3, "name": "保溫區", "unit": "°C", "min": 60, "max": 65},
                    "steam_pressure": {"channel": 4, "name": "蒸汽壓力", "unit": "MPa", "min": 0.1, "max": 0.35},
                },
                "alerts": {
                    "low_temp": 2.0,      # 溫度偏低 2°C 以上
                    "high_temp": 2.0,     # 溫度偏高 2°C 以上
                    "critical": True,     # 啟用緊急警報
                },
                "cloud_upload": {
                    "enabled": False,  # 暫停雲端上傳，改為本地儲存
                    "url": "https://api.example.com/temperature",
                    "api_key": "YOUR_API_KEY_HERE"
                }
            }
            # ============= 日誌設定 =============
            os.makedirs(CONFIG["log_path"], exist_ok=True)
            logging.basicConfig(
                level=logging.INFO,
                format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
                handlers=[
                    logging.FileHandler(os.path.join(CONFIG["log_path"], "monitor.log")),
                    logging.StreamHandler()
                ]
            )
            logger = logging.getLogger(__name__)
            # ============= 資料庫初始化 =============
            def init_database():
                """初始化 SQLite 資料庫"""
                os.makedirs(os.path.dirname(CONFIG["db_path"]), exist_ok=True)
                conn = sqlite3.connect(CONFIG["db_path"])
                cursor = conn.cursor()
                cursor.execute('''
                CREATE TABLE IF NOT EXISTS measurements (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
                    sensor_name TEXT NOT NULL,
                    sensor_id TEXT NOT NULL,
                    value REAL NOT NULL,
                    unit TEXT NOT NULL,
                    status TEXT,  -- 'normal', 'warning', 'alert'
                    notes TEXT
                )
                ''')
                cursor.execute('''
                CREATE TABLE IF NOT EXISTS alerts (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
                    sensor_name TEXT NOT NULL,
                    alert_type TEXT,  -- 'low', 'high', 'critical'
                    value REAL NOT NULL,
                    threshold REAL NOT NULL,
                    action_taken TEXT
                )
                ''')
                cursor.execute('''
                CREATE INDEX IF NOT EXISTS idx_measurements_timestamp
                ON measurements(timestamp)
                ''')
                conn.commit()
                conn.close()
                logger.info("Database initialized")
            # ============= 感應器讀取模擬 =============
            def read_sensor(sensor_id, channel):
                """
                從 ADS1256 讀取感應器數據
                實際實現時需加載 Adafruit_ADS1x15 驅動程式
                此處為簡化示意
                """
                try:
                    # 實際程式碼應使用：
                    # import Adafruit_ADS1x15
                    # adc = Adafruit_ADS1x15.ADS1256()
                    # raw_value = adc.read_adc(channel, gain=1)
                    # 開發階段測試數據
                    import random
                    if "cold" in sensor_id:
                        value = 2.5 + random.uniform(-0.5, 0.5)
                    elif "cooking" in sensor_id:
                        value = 68 + random.uniform(-2, 2)
                    elif "warming" in sensor_id:
                        value = 62 + random.uniform(-1, 1)
                    elif "steam" in sensor_id:
                        value = 0.2 + random.uniform(-0.02, 0.02)
                    else:
                        value = 20
                    return value
                except Exception as e:
                    logger.error(f"Failed to read sensor {sensor_id}: {e}")
                    return None
            # ============= 警報邏輯 =============
            def check_alert(sensor_id, sensor_config, value):
                """檢查是否超出警報範圍"""
                alert_status = {
                    "has_alert": False,
                    "alert_type": None,
                    "message": ""
                }
                if value < sensor_config["min"] - CONFIG["alerts"]["low_temp"]:
                    alert_status["has_alert"] = True
                    alert_status["alert_type"] = "low"
                    alert_status["message"] = f"{sensor_config['name']}: 溫度過低 ({value}°C)，低於安全範圍"
                if value > sensor_config["max"] + CONFIG["alerts"]["high_temp"]:
                    alert_status["has_alert"] = True
                    alert_status["alert_type"] = "high"
                    alert_status["message"] = f"{sensor_config['name']}: 溫度過高 ({value}°C)，超過安全範圍"
                if value < sensor_config["min"] - CONFIG["alerts"]["low_temp"] - 1:
                    alert_status["has_alert"] = True
                    alert_status["alert_type"] = "critical"
                    alert_status["message"] = f"⚠️ 危急警報：{sensor_config['name']} 溫度嚴重異常！({value}°C)"
                return alert_status
            # ============= 資料儲存 =============
            def save_measurement(sensor_id, sensor_name, value, unit, alert_info):
                """將測量結果儲存到資料庫"""
                try:
                    conn = sqlite3.connect(CONFIG["db_path"])
                    cursor = conn.cursor()
                    status = "alert" if alert_info["has_alert"] else "normal"
                    cursor.execute('''
                    INSERT INTO measurements (sensor_name, sensor_id, value, unit, status, notes)
                    VALUES (?, ?, ?, ?, ?, ?)
                    ''', (sensor_name, sensor_id, value, unit, status, alert_info.get("message", "")))
                    if alert_info["has_alert"]:
                        cursor.execute('''
                        INSERT INTO alerts (sensor_name, alert_type, value, threshold, action_taken)
                        VALUES (?, ?, ?, ?, ?)
                        ''', (
                            sensor_name,
                            alert_info["alert_type"],
                            value,
                            sensor_config.get("max", 0),
                            "logged"
                        ))
                    conn.commit()
                    conn.close()
                except Exception as e:
                    logger.error(f"Failed to save measurement: {e}")
            # ============= 主監控迴圈 =============
            def monitor_loop():
                """主要監控迴圈，每隔 update_interval 秒采樣一次"""
                init_database()
                logger.info("Temperature monitoring started")
                while True:
                    try:
                        timestamp = datetime.now().isoformat()
                        measurements = {}
                        for sensor_id, sensor_config in CONFIG["sensors"].items():
                            value = read_sensor(sensor_id, sensor_config["channel"])
                            if value is not None:
                                alert_info = check_alert(sensor_id, sensor_config, value)
                                save_measurement(
                                    sensor_id,
                                    sensor_config["name"],
                                    value,
                                    sensor_config["unit"],
                                    alert_info
                                )
                                measurements[sensor_id] = {
                                    "name": sensor_config["name"],
                                    "value": round(value, 2),
                                    "unit": sensor_config["unit"],
                                    "status": "alert" if alert_info["has_alert"] else "normal",
                                    "message": alert_info.get("message", "")
                                }
                                if alert_info["has_alert"]:
                                    logger.warning(alert_info["message"])
                        # 可選：上傳到雲端 (若啟用)
                        if CONFIG["cloud_upload"]["enabled"]:
                            try:
                                requests.post(
                                    CONFIG["cloud_upload"]["url"],
                                    json=measurements,
                                    headers={"Authorization": f"Bearer {CONFIG['cloud_upload']['api_key']}"},
                                    timeout=5
                                )
                            except Exception as e:
                                logger.error(f"Cloud upload failed: {e}")
                        logger.debug(f"Measurements recorded: {measurements}")
                    except Exception as e:
                        logger.error(f"Monitor loop error: {e}")
                    time.sleep(CONFIG["update_interval"])
            # ============= Web API (Flask) =============
            def start_web_api():
                """啟動 Web API 伺服器，提供實時數據查詢"""
                from flask import Flask, jsonify
                app = Flask(__name__)
                @app.route('/api/latest', methods=['GET'])
                def get_latest():
                    """取得最新的所有感應器數據"""
                    try:
                        conn = sqlite3.connect(CONFIG["db_path"])
                        cursor = conn.cursor()
                        cursor.execute('''
                        SELECT sensor_name, value, unit, status, timestamp
                        FROM measurements
                        WHERE timestamp >= datetime('now', '-5 minutes')
                        ORDER BY sensor_name, timestamp DESC
                        ''')
                        results = {}
                        for row in cursor.fetchall():
                            sensor_name, value, unit, status, timestamp = row
                            if sensor_name not in results:
                                results[sensor_name] = {
                                    "value": value,
                                    "unit": unit,
                                    "status": status,
                                    "timestamp": timestamp
                                }
                        conn.close()
                        return jsonify(results)
                    except Exception as e:
                        logger.error(f"API error: {e}")
                        return jsonify({"error": str(e)}), 500
                @app.route('/api/alerts', methods=['GET'])
                def get_alerts():
                    """取得今日的所有警報"""
                    try:
                        conn = sqlite3.connect(CONFIG["db_path"])
                        cursor = conn.cursor()
                        cursor.execute('''
                        SELECT timestamp, sensor_name, alert_type, value, threshold
                        FROM alerts
                        WHERE DATE(timestamp) = DATE('now')
                        ORDER BY timestamp DESC
                        ''')
                        alerts = [
                            {
                                "timestamp": row[0],
                                "sensor": row[1],
                                "type": row[2],
                                "value": row[3],
                                "threshold": row[4]
                            }
                            for row in cursor.fetchall()
                        ]
                        conn.close()
                        return jsonify({"alerts": alerts, "count": len(alerts)})
                    except Exception as e:
                        logger.error(f"API error: {e}")
                        return jsonify({"error": str(e)}), 500
                app.run(host='0.0.0.0', port=5000, debug=False)
            # ============= 主程式 =============
            if __name__ == "__main__":
                # 啟動監控迴圈 (主執行緒)
                monitor_thread = Thread(target=monitor_loop, daemon=False)
                monitor_thread.start()
                # 啟動 Web API (背景執行緒)
                api_thread = Thread(target=start_web_api, daemon=True)
                api_thread.start()
                # 保持程式運行
                try:
                    monitor_thread.join()
                except KeyboardInterrupt:
                    logger.info("Monitoring stopped by user")
            

<!DOCTYPE html>
            <html lang="zh-Hant">
            <head>
                <meta charset="UTF-8">
                <meta name="viewport" content="width=device-width, initial-scale=1.0">
                <title>廚房溫度監控儀表板</title>
                <style>
                    * { margin: 0; padding: 0; box-sizing: border-box; }
                    body {
                        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
                        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
                        min-height: 100vh;
                        padding: 20px;
                    }
                    .container { max-width: 1200px; margin: 0 auto; }
                    h1 { color: white; margin-bottom: 30px; text-align: center; }
                    .dashboard-grid {
                        display: grid;
                        grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
                        gap: 20px;
                    }
                    .sensor-card {
                        background: white;
                        border-radius: 12px;
                        padding: 25px;
                        box-shadow: 0 8px 16px rgba(0, 0, 0, 0.1);
                        transition: transform 0.3s, box-shadow 0.3s;
                    }
                    .sensor-card:hover { transform: translateY(-5px); }
                    .sensor-card.alert {
                        background: #ffebee;
                        border-left: 4px solid #ef4444;
                    }
                    .sensor-name {
                        font-size: 16px;
                        font-weight: 600;
                        color: #333;
                        margin-bottom: 10px;
                    }
                    .sensor-value {
                        font-size: 36px;
                        font-weight: bold;
                        color: #667eea;
                        margin: 15px 0;
                    }
                    .sensor-value.alert { color: #ef4444; }
                    .sensor-timestamp {
                        font-size: 12px;
                        color: #999;
                        margin-top: 10px;
                    }
                    .status-dot {
                        display: inline-block;
                        width: 12px;
                        height: 12px;
                        border-radius: 50%;
                        background: #22c55e;
                        margin-right: 8px;
                    }
                    .status-dot.alert { background: #ef4444; }
                    </style>
                </head>
                <body>
                    <div class="container">
                        <h1>🌡️ 學校廚房溫度監控系統</h1>
                        <div class="dashboard-grid" id="dashboard"></div>
                    </div>
                    <script>
                        async function updateDashboard() {
                            try {
                                const response = await fetch('/api/latest');
                                const data = await response.json();
                                const dashboard = document.getElementById('dashboard');
                                dashboard.innerHTML = '';
                                for (const [key, value] of Object.entries(data)) {
                                    const card = document.createElement('div');
                                    card.className = 'sensor-card' + (value.status === 'alert' ? ' alert' : '');
                                    card.innerHTML = `
                                        <div class="sensor-name">
                                            <span class="status-dot${value.status === 'alert' ? ' alert' : ''}"></span>
                                            ${key}
                                        </div>
                                        <div class="sensor-value${value.status === 'alert' ? ' alert' : ''}">
                                            ${value.value} ${value.unit}
                                        </div>
                                        <div class="sensor-timestamp">
                                            更新：${new Date(value.timestamp).toLocaleString('zh-TW')}
                                        </div>
                                    `;
                                    dashboard.appendChild(card);
                                }
                            } catch (error) {
                                console.error('Failed to fetch data:', error);
                            }
                        }
                        // 每 10 秒更新一次
                        updateDashboard();
                        setInterval(updateDashboard, 10000);
                    </script>
                </body>
            </html>

#!/bin/bash
            # 每日備份溫度監控數據
            BACKUP_DIR="/mnt/backup/temperature-monitor"
            DB_PATH="/var/lib/temperature_monitor/data.db"
            DATE=$(date +%Y%m%d)
            mkdir -p $BACKUP_DIR
            # 備份資料庫
            cp $DB_PATH $BACKUP_DIR/data_${DATE}.db
            # 備份日誌
            tar -czf $BACKUP_DIR/logs_${DATE}.tar.gz /var/log/temperature_monitor/
            # 刪除 30 天前的備份
            find $BACKUP_DIR -name "data_*.db" -mtime +30 -delete
            find $BACKUP_DIR -name "logs_*.tar.gz" -mtime +30 -delete
            echo "Backup completed: $DATE" | mail -s "Temperature Monitor Backup" admin@school.edu

0 2 * * * /home/pi/backup.sh 2>&1 | logger -t temperature-backup