樓宇自動化入門：房間溫度控制器的集成

u(t) = Kp * e(t) + Ki * ∫e(t)dt + Kd * de(t)/dt
                其中：
                  e(t) = 設定溫度 - 實際溫度（誤差）
                  Kp = 比例增益
                  Ki = 積分增益
                  Kd = 微分增益

┌─────────────────────────────────────────────┐
                │  樓宇管理平台（Drupal / Node.js / Django）   │  （雲端或本地）
                │         監控儀表板 / 告警 / 報表              │
                └──────────────┬──────────────┬────────────────┘
                               │              │
                        Modbus TCP      MQTT / REST API
                               │              │
                    ┌──────────┴──────────┬───┴─────────┐
                    │                     │              │
                ┌───▼─────────┐ ┌────────▼────┐  ┌─────▼────┐
                │ 網關設備     │ │ MQTT Broker │  │  API     │
                │(工業網關)   │ │ (Mosquitto) │  │ 閘道器   │
                └───┬─────────┘ └─────────────┘  └──────────┘
                    │ Modbus RTU (RS485)
                    │
                    ├──────────┬────────────┬──────────┐
                    │          │            │          │
                ┌───▼──┐ ┌───▼──┐ ┌──────▼──┐ ┌────▼──┐
                │房間  │ │房間  │ │ 走廊    │ │機房   │
                │控制1 │ │控制2 │ │控制器   │ │控制器 │
                └──────┘ └──────┘ └─────────┘ └───────┘
                   ↓        ↓         ↓          ↓
                 [感測器] [感測器] [感測器] [感測器]
                    

#!/usr/bin/env python3
                # -*- coding: utf-8 -*-
                """
                MQTT 溫度採集器 - 用於房間溫度控制器
                適用於 Raspberry Pi、工控主機、邊界計算設備
                """
                import paho.mqtt.client as mqtt
                import time
                import json
                import logging
                from datetime import datetime
                from smbus import SMBus  # I2C 溫度感測器讀取
                # 設定日誌
                logging.basicConfig(
                    level=logging.INFO,
                    format='%(asctime)s - %(levelname)s - %(message)s'
                )
                logger = logging.getLogger(__name__)
                class MQTTTempCollector:
                    def __init__(self, broker_host, broker_port=1883, device_id="room_01"):
                        self.broker_host = broker_host
                        self.broker_port = broker_port
                        self.device_id = device_id
                        self.topic = f"atlantis/bms/{device_id}/temperature"
                        self.client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION1)
                        # 設置回調函數
                        self.client.on_connect = self.on_connect
                        self.client.on_disconnect = self.on_disconnect
                        self.client.on_message = self.on_message
                        self.is_connected = False
                        self.target_temp = 22.0  # 預設目標溫度
                        self.i2c_bus = SMBus(1)  # Raspberry Pi I2C 匯流排 1
                        self.sensor_addr = 0x48  # I2C 溫度感測器地址（可調整）
                    def on_connect(self, client, userdata, flags, rc):
                        if rc == 0:
                            logger.info(f"成功連接到 MQTT Broker: {self.broker_host}")
                            self.is_connected = True
                            # 訂閱設定溫度命令
                            client.subscribe(f"atlantis/bms/{self.device_id}/set_temp")
                        else:
                            logger.error(f"連接失敗，錯誤碼: {rc}")
                    def on_disconnect(self, client, userdata, rc):
                        if rc != 0:
                            logger.warning(f"意外斷線: {rc}")
                        self.is_connected = False
                    def on_message(self, client, userdata, msg):
                        """接收遠端設定溫度命令"""
                        try:
                            payload = json.loads(msg.payload.decode())
                            self.target_temp = payload.get("temperature", 22.0)
                            logger.info(f"收到遠端溫度設定: {self.target_temp}°C")
                        except Exception as e:
                            logger.error(f"解析遠端命令出錯: {e}")
                    def read_temperature_i2c(self):
                        """從 I2C 溫度感測器讀取溫度"""
                        try:
                            # 假設使用 LM75 溫度感測器（I2C）
                            data = self.i2c_bus.read_i2c_block_data(self.sensor_addr, 0, 2)
                            raw_temp = (data[0] << 8) | data[1]
                            temperature = raw_temp >> 7  # 左移 7 位得到溫度值
                            return round(temperature * 0.5, 1)
                        except Exception as e:
                            logger.error(f"讀取溫度感測器失敗: {e}")
                            return None
                    def read_temperature_analog(self, adc_channel=0):
                        """從類比輸入（例如 ADC）讀取 Pt100 RTD 溫度"""
                        try:
                            # 使用 ADS1115 12-bit ADC 讀取 4-20mA 信號
                            # 需要另外安裝: pip install adafruit-circuitpython-ads1x15
                            import board
                            import busio
                            import adafruit_ads1x15.ads1115 as ads1115
                            i2c = busio.I2C(board.SCL, board.SDA)
                            ads = ads1115.ADS1115(i2c)
                            # 讀取 A0 通道，映射到溫度範圍
                            raw = ads.value
                            # 線性映射: 4mA (0V) → 0°C, 20mA (5V) → 100°C
                            voltage = (raw / 32767.0) * 5.0
                            temperature = ((voltage - 0.8) / 3.92) * 100
                            return round(temperature, 2)
                        except Exception as e:
                            logger.error(f"讀取類比溫度失敗: {e}")
                            return None
                    def publish_data(self):
                        """發布溫度數據到 MQTT"""
                        temp = self.read_temperature_i2c()
                        if temp is None:
                            return
                        payload = {
                            "timestamp": datetime.now().isoformat(),
                            "device_id": self.device_id,
                            "actual_temperature": temp,
                            "target_temperature": self.target_temp,
                            "status": "OK"
                        }
                        try:
                            self.client.publish(
                                self.topic,
                                json.dumps(payload),
                                qos=1,
                                retain=False
                            )
                            logger.info(f"發布數據: {temp}°C (目標: {self.target_temp}°C)")
                        except Exception as e:
                            logger.error(f"發布失敗: {e}")
                    def run(self, interval=5):
                        """啟動採集迴圈"""
                        try:
                            self.client.connect(self.broker_host, self.broker_port, keepalive=60)
                            self.client.loop_start()
                            logger.info(f"開始溫度採集，採樣間隔: {interval}秒")
                            while True:
                                if self.is_connected:
                                    self.publish_data()
                                time.sleep(interval)
                        except KeyboardInterrupt:
                            logger.info("收到停止信號，正在關閉...")
                        finally:
                            self.client.loop_stop()
                            self.client.disconnect()
                            logger.info("已斷開連接")
                # 使用範例
                if __name__ == "__main__":
                    # 替換為你的 MQTT Broker 地址
                    collector = MQTTTempCollector(
                        broker_host="192.168.1.100",
                        device_id="room_101"
                    )
                    collector.run(interval=5)  # 每 5 秒採集一次

// modbus_gateway.js
                // MQTT/Modbus 整合閘道器 - 用於樓宇自動化
                const express = require('express');
                const ModbusRTU = require('modbus-serial');
                const mqtt = require('mqtt');
                const cors = require('cors');
                const app = express();
                app.use(express.json());
                app.use(cors());
                const PORT = 3000;
                const MODBUS_HOST = '192.168.1.50';  // 工控主機 IP
                const MODBUS_PORT = 502;
                const MQTT_BROKER = 'mqtt://192.168.1.100';
                // 全域狀態
                const state = {
                  devices: {},
                  connected: {
                    modbus: false,
                    mqtt: false
                  }
                };
                // Modbus RTU Master
                const master = new ModbusRTU();
                master.connectTCP(MODBUS_HOST, { port: MODBUS_PORT })
                  .then(() => {
                    console.log('Modbus TCP 已連接');
                    state.connected.modbus = true;
                  })
                  .catch(err => {
                    console.error('Modbus TCP 連接失敗:', err);
                  });
                // MQTT 用戶端
                const mqttClient = mqtt.connect(MQTT_BROKER);
                mqttClient.on('connect', () => {
                  console.log('MQTT 已連接');
                  state.connected.mqtt = true;
                  // 訂閱所有溫度數據
                  mqttClient.subscribe('atlantis/bms/+/temperature', (err) => {
                    if (err) console.error('訂閱失敗:', err);
                  });
                });
                mqttClient.on('message', (topic, message) => {
                  try {
                    const data = JSON.parse(message.toString());
                    const deviceId = data.device_id;
                    // 存儲設備狀態
                    state.devices[deviceId] = {
                      ...state.devices[deviceId],
                      actualTemp: data.actual_temperature,
                      targetTemp: data.target_temperature,
                      lastUpdate: new Date()
                    };
                    console.log(`[${deviceId}] 溫度: ${data.actual_temperature}°C`);
                  } catch (e) {
                    console.error('MQTT 訊息解析失敗:', e);
                  }
                });
                // REST API 端點
                // 1. 讀取所有設備狀態
                app.get('/api/devices', (req, res) => {
                  res.json({
                    connected: state.connected,
                    devices: state.devices
                  });
                });
                // 2. 讀取特定設備溫度（Modbus RTU）
                app.get('/api/devices/:deviceId/temperature', async (req, res) => {
                  try {
                    const { deviceId } = req.params;
                    const slaveId = parseInt(deviceId) || 1;
                    // 讀取 Modbus 暫存器 (寄存器 100: 實際溫度 * 100)
                    master.setID(slaveId);
                    const data = await master.readHoldingRegisters(100, 2);
                    const actualTemp = data.data[0] / 100;
                    const targetTemp = data.data[1] / 100;
                    res.json({
                      deviceId,
                      actualTemp: parseFloat(actualTemp.toFixed(2)),
                      targetTemp: parseFloat(targetTemp.toFixed(2)),
                      status: 'OK'
                    });
                  } catch (error) {
                    res.status(500).json({
                      error: error.message
                    });
                  }
                });
                // 3. 設定目標溫度（Modbus RTU）
                app.post('/api/devices/:deviceId/set-temperature', async (req, res) => {
                  try {
                    const { deviceId } = req.params;
                    const { temperature } = req.body;
                    const slaveId = parseInt(deviceId) || 1;
                    if (temperature < 15 || temperature > 30) {
                      return res.status(400).json({
                        error: '溫度範圍必須在 15-30°C 之間'
                      });
                    }
                    // 寫入 Modbus 暫存器 (寄存器 101: 目標溫度 * 100)
                    master.setID(slaveId);
                    await master.writeRegister(101, Math.round(temperature * 100));
                    res.json({
                      deviceId,
                      setTemp: temperature,
                      status: 'SET_OK',
                      timestamp: new Date().toISOString()
                    });
                  } catch (error) {
                    res.status(500).json({
                      error: error.message
                    });
                  }
                });
                // 4. 獲取設備詳細資訊
                app.get('/api/devices/:deviceId', (req, res) => {
                  const device = state.devices[req.params.deviceId];
                  if (!device) {
                    return res.status(404).json({ error: '設備未找到' });
                  }
                  res.json(device);
                });
                // 5. 系統健康檢查
                app.get('/api/health', (req, res) => {
                  res.json({
                    status: 'OK',
                    connected: state.connected,
                    uptime: process.uptime(),
                    timestamp: new Date().toISOString()
                  });
                });
                // 定時讀取 Modbus 數據
                setInterval(async () => {
                  if (!state.connected.modbus) return;
                  try {
                    for (let slaveId = 1; slaveId <= 4; slaveId++) {
                      master.setID(slaveId);
                      const data = await master.readHoldingRegisters(100, 2)
                        .catch(() => null);
                      if (data) {
                        state.devices[`slave_${slaveId}`] = {
                          slaveId,
                          actualTemp: data.data[0] / 100,
                          targetTemp: data.data[1] / 100,
                          lastUpdate: new Date()
                        };
                      }
                    }
                  } catch (err) {
                    console.error('Modbus 讀取迴圈錯誤:', err);
                  }
                }, 10000);  // 每 10 秒讀取一次
                app.listen(PORT, () => {
                  console.log(`\n▶ 樓宇自動化網關已啟動 | http://0.0.0.0:${PORT}`);
                  console.log(`├─ REST API: /api/*`);
                  console.log(`├─ Modbus TCP: ${MODBUS_HOST}:${MODBUS_PORT}`);
                  console.log(`└─ MQTT Broker: ${MQTT_BROKER}\n`);
                });

/*
                 * 樓宇自動化房間溫度控制器 - Arduino 版本
                 * 硬體：Arduino Mega 2560 + MAX31865 RTD 驅動模組
                 * 通訊：Modbus RTU (RS485)
                 *
                 * 安裝庫：
                 *   - ArduinoModbus (官方)
                 *   - Adafruit_MAX31865 (RTD 驅動)
                 */
                #include 
                #include 
                #include "Adafruit_MAX31865.h"
                // Modbus 設置
                const int MODBUS_SLAVE_ID = 1;
                const long BAUD_RATE = 9600;
                // RTD 驅動 (SPI 接口)
                Adafruit_MAX31865 rtd = Adafruit_MAX31865(10, 11, 12, 13);  // CS, MOSI, MISO, SCK
                // 繼電器控制輸出引腳
                const int COOL_RELAY = 22;    // 冷氣繼電器
                const int HEAT_RELAY = 23;    // 暖氣繼電器
                // Modbus 暫存器
                const int HOLDING_REGISTERS_COUNT = 10;
                uint16_t holdingRegisters[HOLDING_REGISTERS_COUNT];
                // 系統狀態
                float currentTemperature = 0.0;
                float targetTemperature = 22.0;
                unsigned long lastReadTime = 0;
                const unsigned long READ_INTERVAL = 1000;  // 每 1000ms 讀取一次
                void setup() {
                  Serial.begin(BAUD_RATE);
                  // 初始化 RTD
                  if (!rtd.begin(MAX31865_3WIRE)) {
                    Serial.println("ERROR: RTD 初始化失敗!");
                    while (1) delay(100);
                  }
                  // 初始化繼電器
                  pinMode(COOL_RELAY, OUTPUT);
                  pinMode(HEAT_RELAY, OUTPUT);
                  digitalWrite(COOL_RELAY, LOW);
                  digitalWrite(HEAT_RELAY, LOW);
                  // 初始化 Modbus RTU 從機
                  if (!ModbusRTUServer.begin(MODBUS_SLAVE_ID, BAUD_RATE)) {
                    Serial.println("ERROR: Modbus 初始化失敗!");
                    while (1) delay(100);
                  }
                  // 初始化 Modbus 暫存器
                  for (int i = 0; i < HOLDING_REGISTERS_COUNT; i++) {
                    ModbusRTUServer.configureHoldingRegisters(i, 1);
                  }
                  Serial.println("樓宇自動化房間控制器已就緒");
                  Serial.print("Slave ID: ");
                  Serial.println(MODBUS_SLAVE_ID);
                }
                void loop() {
                  // 處理 Modbus 請求
                  ModbusRTUServer.poll();
                  // 定期讀取溫度
                  if (millis() - lastReadTime >= READ_INTERVAL) {
                    readTemperature();
                    lastReadTime = millis();
                  }
                  // 執行 PID 溫度控制
                  controlTemperature();
                  // 更新 Modbus 暫存器
                  updateRegisters();
                  delay(10);
                }
                void readTemperature() {
                  uint8_t fault = rtd.readFault();
                  if (fault) {
                    Serial.print("RTD 故障代碼: 0x");
                    Serial.println(fault, HEX);
                    // 故障排查
                    if (fault & MAX31865_FAULT_HIGHTHRESH) {
                      Serial.println("  ├─ 溫度超過上限");
                    }
                    if (fault & MAX31865_FAULT_LOWTHRESH) {
                      Serial.println("  ├─ 溫度低於下限");
                    }
                    if (fault & MAX31865_FAULT_RTDINLOW) {
                      Serial.println("  ├─ RTD 電阻過低（開路故障）");
                    }
                    if (fault & MAX31865_FAULT_REFIN) {
                      Serial.println("  └─ REFIN 異常（接線問題）");
                    }
                    rtd.clearFault();
                  } else {
                    currentTemperature = rtd.temperature(100.0, 430.0);
                    Serial.print("溫度: ");
                    Serial.print(currentTemperature);
                    Serial.println("°C");
                  }
                }
                void controlTemperature() {
                  float error = targetTemperature - currentTemperature;
                  const float HYSTERESIS = 0.5;  // 溫度遲滯
                  // 簡單的 ON/OFF 控制（實際應用可改為 PID）
                  if (error > HYSTERESIS) {
                    // 溫度過低，啟動暖氣
                    digitalWrite(HEAT_RELAY, HIGH);
                    digitalWrite(COOL_RELAY, LOW);
                  }
                  else if (error < -HYSTERESIS) {
                    // 溫度過高，啟動冷氣
                    digitalWrite(COOL_RELAY, HIGH);
                    digitalWrite(HEAT_RELAY, LOW);
                  }
                  else {
                    // 溫度適中，關閉兩個繼電器
                    digitalWrite(COOL_RELAY, LOW);
                    digitalWrite(HEAT_RELAY, LOW);
                  }
                }
                void updateRegisters() {
                  // 暫存器配置（Modbus 標準）
                  // Reg 100: 實際溫度 (°C * 100)
                  holdingRegisters[0] = (uint16_t)(currentTemperature * 100);
                  ModbusRTUServer.holdingRegisterWrite(0, holdingRegisters[0]);
                  // Reg 101: 目標溫度 (°C * 100)
                  targetTemperature = ModbusRTUServer.holdingRegisterRead(1) / 100.0;
                  holdingRegisters[1] = (uint16_t)(targetTemperature * 100);
                  // Reg 102: 控制狀態 (bit 0=冷氣, bit 1=暖氣)
                  uint16_t status = 0;
                  if (digitalRead(COOL_RELAY) == HIGH) status |= 0x01;
                  if (digitalRead(HEAT_RELAY) == HIGH) status |= 0x02;
                  ModbusRTUServer.holdingRegisterWrite(2, status);
                  // Reg 103: 故障狀態 (0=OK, 1=故障)
                  uint8_t fault = rtd.readFault();
                  ModbusRTUServer.holdingRegisterWrite(3, fault ? 1 : 0);
                }
                // 故障恢復函式
                void handleRTDFault() {
                  Serial.println("--- RTD 故障診斷 ---");
                  Serial.print("電阻值: ");
                  Serial.print(rtd.readRTD());
                  Serial.println(" Ω");
                  // 建議動作
                  Serial.println("排查步驟:");
                  Serial.println("1. 檢查 RTD 傳感器接線（2/3/4 線制）");
                  Serial.println("2. 確認引線是否斷開或接觸不良");
                  Serial.println("3. 檢查 MAX31865 模組電源");
                  Serial.println("4. 更換 RTD 傳感器");
                }