node-red-contrib-symi-mesh 1.8.1 → 1.8.3

package/README.md

@@ -393,16 +393,47 @@ Symi HA同步节点 (`symi-ha-sync`) 用于实现Symi蓝牙Mesh设备与Home Ass
    - 复用`symi-mqtt`配置节点获取Symi设备信息
    - 复用`server`配置节点连接Home Assistant
 2. **双向同步**：
-   - **Symi -> HA**：Mesh设备状态变化 -> 更新HA实体状态
-   - **HA -> Symi**：HA实体状态变化 -> 控制Mesh设备
+   - **Symi -> HA**：Mesh设备状态变化 -> 更新HA实体状态（自动工作）
+   - **HA -> Symi**：HA实体状态变化 -> 控制Mesh设备（需连接HA事件节点）
 3. **防死循环**：
-   - 内置800ms冷却机制
+   - 内置2秒冷却机制（窗帘30秒）
    - 区分Symi触发和HA触发，避免信号震荡
 4. **便捷配置**：
    - 自动加载所有Symi设备和HA实体
    - 支持按键通道选择（1-4键）
    - 支持实体ID搜索和下拉选择
 
+#### ⚠️ 双向同步连接方式（重要）
+
+要实现完整的双向同步，必须连接HA事件节点到`symi-ha-sync`节点的输入端：
+
+**方式1：使用 server-events 节点（推荐）**
+```
+[events: all] → [symi-ha-sync]
+  (事件类型: state_changed)
+```
+
+配置步骤：
+1. 添加 `events: all` 节点（Home Assistant 分类下）
+2. 事件类型(Event Type)填写: `state_changed`
+3. 将输出连接到 symi-ha-sync 节点的输入端
+
+**方式2：使用 server-state-changed 节点**
+```
+[events: state] → [symi-ha-sync]
+```
+
+配置步骤：
+1. 添加 `events: state` 节点
+2. 实体ID可留空（监听所有实体）或指定特定实体
+3. 将输出连接到 symi-ha-sync 节点的输入端
+
+#### 状态指示
+
+- **蓝色 "Mesh→HA (N组)"**：仅 Mesh 到 HA 方向工作（未连接 HA 事件节点）
+- **绿色 "双向同步 (N组)"**：双向同步正常工作
+- **红色**：配置错误
+
 #### 配置步骤
 
 1. **添加节点**：从左侧拖入`Symi HA Sync`节点
@@ -413,14 +444,98 @@ Symi HA同步节点 (`symi-ha-sync`) 用于实现Symi蓝牙Mesh设备与Home Ass
    - **Symi设备**：下拉选择Mesh设备（显示名称和MAC）
    - **按键**：选择控制通道（按键1-4）
    - **HA实体**：输入或选择要同步的HA实体ID（如`switch.living_room_light`）
-5. **部署**：点击部署，立即生效
+5. **连接HA事件节点**：添加`events: all`或`events: state`节点，连接到输入端
+6. **部署**：点击部署，立即生效
 
 #### 注意事项
 
 - **MQTT配置**：必须选择`symi-mqtt`配置节点，用于获取设备列表和接收Mesh事件
 - **HA连接**：必须确保HA服务器节点连接正常
+- **HA事件节点**：必须连接HA事件节点才能实现HA→Symi方向同步
 - **实体类型**：建议同步相同类型的实体（如开关对开关，调光灯对灯光）
 - **多通道设备**：对于多键开关，请分别为每个按键添加一条映射
+- **event实体过滤**：系统自动过滤`event.`开头的实体（如按键点击事件），不会同步
+
+#### 三合一面板配置
+
+三合一面板（空调+新风+地暖）需要分别配置每个子设备的映射：
+
+1. **选择三合一设备**：在Symi设备下拉框中选择三合一面板
+2. **选择子设备**：在按键选择器中选择要同步的功能：
+   - **空调**：同步开关、温度、模式、风速
+   - **新风**：同步开关、风速
+   - **地暖**：同步开关、温度
+3. **选择HA实体**：
+   - 空调 → climate实体
+   - 新风 → fan实体
+   - 地暖 → climate实体
+
+**示例配置**：
+```
+三合一面板_xxx [空调] ↔ climate.living_room_ac
+三合一面板_xxx [新风] ↔ fan.living_room_fresh_air
+三合一面板_xxx [地暖] ↔ climate.living_room_floor_heating
+```
+
+#### 窗帘同步说明
+
+窗帘设备采用特殊的同步机制，避免运动过程中的步进反馈干扰：
+
+- **30秒防死循环窗口**：窗帘运动时间较长，使用30秒防死循环（普通设备2秒）
+- **1.5秒防抖**：等待窗帘位置稳定后再同步，避免步进码干扰
+- **运动状态跟踪**：记录运动发起方（Symi/HA），忽略对方的中间状态反馈
+- **opening/closing过滤**：HA窗帘处于运动状态时，不同步位置变化到Mesh
+
+
+### MQTT品牌同步
+
+Symi MQTT同步节点 (`symi-mqtt-sync`) 用于实现第三方MQTT品牌设备与Symi Mesh设备的双向状态同步。
+
+#### 功能特性
+
+1. **双MQTT配置**：
+   - Mesh MQTT：连接Symi网关获取设备列表
+   - 品牌MQTT：连接第三方品牌MQTT服务器
+2. **设备自动发现**：品牌MQTT连接后自动发现设备
+3. **双向同步**：品牌设备↔Mesh设备实时状态同步
+4. **配置持久化**：设备列表和映射配置持久保存，断线后仍可显示
+
+#### 支持的品牌协议
+
+| 品牌 | 设备类型 | 功能码映射 |
+|------|---------|-----------|
+| HYQW（花语前湾） | 灯具(8) | 开关(fn=1)、亮度(fn=2, 0-100) |
+| | 空调(12) | 开关(fn=1)、温度(fn=2, 18-29°C)、模式(fn=3)、风速(fn=4) |
+| | 窗帘(14) | 动作(fn=1, 开/关/停)、位置(fn=2, 0-100%) |
+| | 地暖(16) | 开关(fn=1)、温度(fn=2, 5-35°C) |
+| | 新风(36) | 开关(fn=1)、风速(fn=3) |
+
+#### 配置步骤
+
+1. **添加品牌MQTT配置节点**：
+   - 从左侧拖入`Symi MQTT Brand`配置节点
+   - 配置品牌MQTT服务器地址、用户名、密码
+   - 选择品牌协议（如HYQW）
+
+2. **添加MQTT同步节点**：
+   - 从左侧拖入`Symi MQTT Sync`节点
+   - 选择Mesh MQTT配置（用于获取Mesh设备）
+   - 选择品牌MQTT配置（用于获取品牌设备）
+
+3. **配置实体映射**：
+   - 点击"添加"按钮
+   - 左侧选择Mesh设备（多路开关可选择按键）
+   - 右侧选择品牌设备
+   - 可添加多组映射
+
+4. **部署**：点击部署，开始双向同步
+
+#### 注意事项
+
+- **设备类型匹配**：建议同步相同类型的设备（灯具对灯具，空调对空调）
+- **离线设备显示**：[离线]标记缓存中但当前不在线的设备
+- **防死循环**：内置2秒防抖机制，避免状态震荡
+- **自动重连**：5秒重连间隔，断线自动恢复
 
 
 ## 协议说明
@@ -1332,8 +1447,8 @@ A: 每个房间部署一个云端同步节点，配置对应的酒店ID和房间
 | **Symi KNX Bridge** | KNX系统双向同步 | [KNX双向同步](#knx双向同步) |
 | **Symi KNX-HA Bridge** | KNX与HA实体双向同步 | [KNX-HA双向同步](#knx-ha双向同步) |
 | **Symi HA Sync** | HA实体双向同步 | [HA双向同步](#ha双向同步) |
-| **Symi MQTT Sync** | 第三方MQTT品牌设备同步 | v1.7.3新增 |
-| **Symi MQTT Brand** | 品牌MQTT配置节点 | v1.7.3新增 |
+| **Symi MQTT Sync** | 第三方MQTT品牌设备同步 | [MQTT品牌同步](#mqtt品牌同步) |
+| **Symi MQTT Brand** | 品牌MQTT配置节点 | [MQTT品牌同步](#mqtt品牌同步) |
 | **RS485 Debug** | RS485总线数据抓包调试 | [RS485调试节点](#rs485调试节点) |
 | **Symi RS485 Sync** | 两种RS485协议双向同步 | [RS485协议同步](#rs485协议同步) |
 
@@ -1420,6 +1535,28 @@ node-red-contrib-symi-mesh/
 - 无TODO/FIXME/HACK标记
 - 代码无重复，模块化设计
 
+## 更新日志
+
+### v1.8.3 (2026-01-05)
+
+**HA同步节点重大修复**：
+- 修复HA→Symi方向不工作的问题（input监听器未正确注册）
+- 支持多种HA节点消息格式（server-events、server-state-changed、trigger:state等）
+- 自动过滤event类型实体（如按键点击事件），避免无效同步
+- 优化状态显示：蓝色"Mesh→HA"表示单向，绿色"双向同步"表示双向正常
+- 精简日志输出，只记录映射中的实体状态变化
+- 更新HTML帮助文档，详细说明双向同步连接方式
+- 更新README文档，添加完整的HA同步配置指南
+
+**连接方式说明**：
+- Symi→HA：自动工作，无需额外配置
+- HA→Symi：需连接`events: all`或`events: state`节点到symi-ha-sync输入端
+
+### v1.8.2 (2025-12-xx)
+
+- 窗帘和调光灯智能防抖，只同步最终状态
+- 三合一面板完整双向同步支持
+
 ## 技术支持
 
 如遇问题，请提供以下信息：
@@ -1503,6 +1640,33 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
+### v1.8.3 (2026-01-05)
+
+**HA同步节点重大修复**：
+- 修复HA→Symi方向不工作的问题（input监听器未正确注册）
+- 支持多种HA节点消息格式（server-events、server-state-changed、trigger:state等）
+- 自动过滤event类型实体（如按键点击事件），避免无效同步
+- 优化状态显示：蓝色"Mesh→HA"表示单向，绿色"双向同步"表示双向正常
+- 精简日志输出，只记录映射中的实体状态变化
+- 更新HTML帮助文档，详细说明双向同步连接方式
+- 更新README文档，添加完整的HA同步配置指南
+
+**连接方式说明**：
+- Symi→HA：自动工作，无需额外配置
+- HA→Symi：需连接`events: all`或`events: state`节点到symi-ha-sync输入端
+
+### v1.8.2 (2026-01-05)
+- **MQTT品牌同步协议修复**：
+  - **窗帘设备协议修复**：修复窗帘fn=1功能码的正确解析（0=关闭, 1=打开, 2=停止），之前错误地当作开关处理
+  - **设备类型独立处理**：重构syncToMesh和syncToMqtt函数，按设备类型(8/12/14/16/36)独立处理功能码映射
+  - **完整功能码支持**：
+    - 灯具(8): fn=1开关, fn=2亮度
+    - 空调(12): fn=1开关, fn=2温度, fn=3模式, fn=4风速
+    - 窗帘(14): fn=1动作(开/关/停), fn=2位置
+    - 地暖(16): fn=1开关, fn=2温度
+    - 新风(36): fn=1开关, fn=3风速
+  - **错误日志增强**：同步失败时输出详细错误信息，便于调试
+
 ### v1.8.1 (2026-01-05)
 - **三合一面板深度集成**：
   - **子设备选择**：HA同步节点新增三合一子设备选择功能，可分别选择“空调”、“新风”、“地暖”进行独立映射。
@@ -1533,62 +1697,6 @@ node-red-contrib-symi-mesh/
   - 优化了双向同步的防死循环逻辑，减少了在高频触发场景下的 CPU 占用。
   - 修复了 MQTT 配置下拉框在节点编辑面板打开时偶尔出现的加载卡顿问题。
 
-### v1.7.9 (2026-01-05)
-- **HA同步节点UI修复**：修复添加映射按钮不显示选择界面的问题
-  - 修复`renderMappings()`函数中的数组检查逻辑
-  - 修复`mergeDevices()`函数中的空值检查
-  - 使用`entityType`字段判断设备类型（climate/cover/light不显示按键选择）
-  - 添加设备类型标签显示：[温控器]、[窗帘]、[灯具]、[N路开关]、[单路开关]
-  - 添加错误捕获和日志输出，便于调试
-
-### v1.7.8 (2026-01-05)
-- **配置持久化增强**：所有同步节点的设备列表和映射配置持久保存
-  - **MQTT同步节点**：Mesh设备和品牌设备列表持久化，断线后仍可显示已配置的映射
-  - **HA同步节点**：Symi设备和HA实体列表持久化，断线后仍可显示已配置的映射
-  - **RS485桥接节点**：Mesh设备列表持久化，断线后仍可显示已配置的映射
-  - **离线设备显示**：[离线]标记缓存中但当前不在线的设备，[未找到]标记不在缓存中的设备
-  - **刷新按钮**：各节点添加独立刷新按钮，可手动刷新设备列表
-- **MQTT品牌同步增强**：完整对接HYQW（花语前湾）MQTT协议
-  - **完整设备类型支持**：灯具(8)、空调(12)、窗帘(14)、地暖(16)、新风(36)
-  - **功能码映射**：完整的fn/fv到Mesh属性双向转换
-    - 灯具：开关(fn=1)、亮度(fn=2, 0-100)
-    - 空调：开关(fn=1)、温度(fn=2, 18-29°C)、模式(fn=3)、风速(fn=4)
-    - 窗帘：动作(fn=1, 开/关/停)、位置(fn=2, 0-100%)
-    - 地暖：开关(fn=1)、温度(fn=2, 5-35°C)
-    - 新风：开关(fn=1)、风速(fn=3)
-  - **可扩展架构**：BRAND_PROTOCOLS对象支持添加新品牌协议
-  - **双向状态同步**：HYQW↔Mesh实时同步，2秒防抖防死循环
-  - **自动设备发现**：自动发现品牌MQTT设备，限制200个
-  - **错误日志限流**：每60秒最多记录一次错误，避免日志爆炸
-  - **自动重连**：5秒重连间隔，断线自动恢复
-  - **资源清理**：完善的定时器和事件监听器清理机制
-- **HA同步节点完整重构**：实现所有实体类型的完美双向同步
-  - **完整实体类型支持**：
-    - switch/input_boolean：开关状态 (on/off)
-    - light：开关 + 亮度 (0-255 ↔ 0-100)
-    - cover：开/关/停 + 位置 (0-100%)
-    - climate：开关 + 温度 + 模式(cool/heat/fan_only/dry) + 风速(high/medium/low/auto)
-    - fan：开关 + 风速
-  - **Mesh属性完整映射**：
-    - 0x02 开关状态（单路/多路）
-    - 0x03 亮度 (0-100)
-    - 0x05 窗帘运行状态
-    - 0x06 窗帘位置 (0-100)
-    - 0x1B 目标温度 (16-30°C)
-    - 0x1C 风速 (1=高/2=中/3=低/4=自动)
-    - 0x1D 空调模式 (1=制冷/2=制热/3=送风/4=除湿)
-  - **智能按键选择**：只有多路开关才显示按键选择，温控器/窗帘/调光灯显示"-"
-  - **设备类型标签**：自动识别并显示设备类型（[温控器]、[窗帘]、[调光灯]、[N路开关]）
-  - **智能防抖机制**：窗帘和调光灯使用500ms防抖，只同步最终位置/亮度
-  - **防死循环增强**：2秒冷却时间 + 双向时间戳检查
-  - **配置持久化**：设备列表和映射配置持久保存
-  - **内存泄漏防护**：定时清理过期时间戳和防抖定时器
-- **代码质量优化**：
-  - 同步时间戳Map自动清理60秒以上的条目
-  - 设备发现数量限制，防止内存溢出
-  - 完善的节点关闭清理逻辑
-  - 防死循环机制增强：双向时间戳检查
-
 ## 许可证
 
 MIT License
@@ -1600,7 +1708,7 @@ Copyright (c) 2025 SYMI 亖米
 ## 关于
 
 **作者**: SYMI 亖米
-**版本**: 1.8.1
+**版本**: 1.8.3
 **协议**: 蓝牙MESH网关（初级版）串口协议V1.0
 **最后更新**: 2026-01-05
 **仓库**: https://github.com/symi-daguo/node-red-contrib-symi-mesh

package/nodes/symi-ha-sync.html

@@ -477,11 +477,44 @@
     <h3>功能特性</h3>
     <ul>
         <li><strong>完美双向同步</strong>：Symi↔HA实时状态同步</li>
-        <li><strong>多设备类型支持</strong>：开关、调光灯、窗帘、温控器/空调</li>
+        <li><strong>多设备类型支持</strong>：开关、调光灯、窗帘、温控器/空调、新风、地暖</li>
         <li><strong>智能按键选择</strong>：只有多路开关才显示按键选择</li>
         <li><strong>配置持久化</strong>：设备列表和映射配置持久保存</li>
         <li><strong>防死循环</strong>：内置2秒防抖机制</li>
-        <li><strong>智能防抖</strong>：窗帘/调光灯只同步最终位置</li>
+        <li><strong>智能防抖</strong>：窗帘/调光灯只同步最终位置，过程状态不同步</li>
+    </ul>
+
+    <h3>⚠️ 双向同步连接方式（重要）</h3>
+    <p>要实现 HA→Symi 方向同步，必须连接 HA 事件节点到本节点输入端：</p>
+    
+    <h4>方式1：使用 server-events 节点（推荐）</h4>
+    <pre>
+[server-events] → [symi-ha-sync]
+    (事件类型: state_changed)
+    </pre>
+    <p><strong>配置步骤：</strong></p>
+    <ol>
+        <li>添加 <code>events: all</code> 节点（Home Assistant 分类下）</li>
+        <li>事件类型(Event Type)填写: <code>state_changed</code></li>
+        <li>将输出连接到 symi-ha-sync 节点的输入端</li>
+    </ol>
+    
+    <h4>方式2：使用 server-state-changed 节点</h4>
+    <pre>
+[server-state-changed] → [symi-ha-sync]
+    </pre>
+    <p><strong>配置步骤：</strong></p>
+    <ol>
+        <li>添加 <code>events: state</code> 节点</li>
+        <li>实体ID可留空（监听所有实体）或指定特定实体</li>
+        <li>将输出连接到 symi-ha-sync 节点的输入端</li>
+    </ol>
+
+    <h3>状态指示</h3>
+    <ul>
+        <li><strong>蓝色 "Mesh→HA"</strong>：仅 Mesh 到 HA 方向工作（未连接 HA 事件节点）</li>
+        <li><strong>绿色 "双向同步"</strong>：双向同步正常工作</li>
+        <li><strong>红色</strong>：配置错误</li>
     </ul>
 
     <h3>支持的设备类型</h3>
@@ -490,6 +523,15 @@
         <li><strong>调光灯</strong>：开关 + 亮度 (0-100)</li>
         <li><strong>窗帘</strong>：开/关/停 + 位置 (0-100%)</li>
         <li><strong>温控器/空调</strong>：开关 + 温度 + 模式 + 风速</li>
+        <li><strong>三合一面板</strong>：空调 + 新风 + 地暖，分别配置</li>
+    </ul>
+
+    <h3>三合一面板配置</h3>
+    <p>三合一面板需要分别为每个子设备创建映射：</p>
+    <ul>
+        <li><strong>空调</strong>：选择子设备"空调"，映射到 climate 实体</li>
+        <li><strong>新风</strong>：选择子设备"新风"，映射到 fan 实体</li>
+        <li><strong>地暖</strong>：选择子设备"地暖"，映射到 climate 实体</li>
     </ul>
 
     <h3>离线设备显示</h3>

package/nodes/symi-ha-sync.js

@@ -1,6 +1,6 @@
 /**
  * Symi HA Sync Node - Symi设备与Home Assistant实体双向同步
- * 版本: 1.8.1
+ * 版本: 1.8.3
  * 
  * 支持的实体类型和属性：
  * - light: on/off, brightness (0-255)
@@ -15,7 +15,7 @@ module.exports = function(RED) {
     
     // 常量定义
     const LOOP_PREVENTION_MS = 2000;  // 防死循环时间窗口
-    const DEBOUNCE_MS = 500;          // 防抖时间（调光用）
+    const DEBOUNCE_MS = 500;          // 通用防抖时间
     const MAX_QUEUE_SIZE = 100;
     const CLEANUP_INTERVAL_MS = 60000;
     const TIMESTAMP_EXPIRE_MS = 60000;
@@ -23,6 +23,9 @@ module.exports = function(RED) {
     // 窗帘专用常量
     const COVER_LOOP_PREVENTION_MS = 30000; // 30秒防死循环
     const COVER_DEBOUNCE_MS = 1500;         // 1.5秒防抖
+    
+    // 调光专用常量
+    const BRIGHTNESS_DEBOUNCE_MS = 800;     // 0.8秒防抖，过滤步进过程
 
     // Mesh属性类型
     const ATTR_SWITCH = 0x02;
@@ -92,28 +95,49 @@ module.exports = function(RED) {
         node.lastHaToSymi = {};
         node.pendingDebounce = {};  // 防抖定时器
         node.coverMoving = {};      // 窗帘运动状态跟踪 { loopKey: { direction: 'symi'|'ha', startTime, targetPosition } }
+        node.brightnessMoving = {}; // 调光运动状态跟踪 { loopKey: { direction: 'ha', startTime } }
+        node.haInputReceived = false;  // 是否收到过HA输入
         
         node.status({ fill: 'yellow', shape: 'ring', text: '初始化中' });
+        
+        // 更新状态显示的辅助函数
+        node.updateStatus = function() {
+            if (configError) {
+                node.status({ fill: 'red', shape: 'ring', text: configError });
+            } else if (node.haInputReceived) {
+                node.status({ fill: 'green', shape: 'dot', text: `双向同步 (${node.mappings.length}组)` });
+            } else if (gateway) {
+                node.status({ fill: 'blue', shape: 'dot', text: `Mesh→HA (${node.mappings.length}组)` });
+            } else {
+                node.status({ fill: 'yellow', shape: 'ring', text: '等待连接' });
+            }
+        };
 
-        // 检查配置
+        // 检查配置 - 但不要直接return，允许input监听器注册
+        let gateway = null;
+        let configError = null;
+        
         if (!node.mqttNode) {
-            node.status({ fill: 'red', shape: 'ring', text: '未配置MQTT节点' });
-            return;
-        }
-        if (!node.haServer) {
-            node.status({ fill: 'red', shape: 'ring', text: '未配置HA服务器' });
-            return;
+            configError = '未配置MQTT节点';
+        } else if (!node.haServer) {
+            configError = '未配置HA服务器';
+        } else {
+            // 获取Gateway引用
+            gateway = node.mqttNode.gateway;
+            if (!gateway) {
+                configError = 'MQTT节点未关联网关';
+            }
         }
-
-        // 获取Gateway引用
-        const gateway = node.mqttNode.gateway;
-        if (!gateway) {
-            node.status({ fill: 'red', shape: 'ring', text: 'MQTT节点未关联网关' });
-            return;
+        
+        if (configError) {
+            node.status({ fill: 'red', shape: 'ring', text: configError });
+            node.warn(`[HA同步] ${configError}`);
+            // 不要return，继续注册input监听器
+        } else {
+            // 初始状态：只有Mesh→HA方向，等待HA输入连接
+            node.updateStatus();
         }
 
-        node.status({ fill: 'green', shape: 'dot', text: `运行中 (${node.mappings.length}组)` });
-
         // 定期清理过期的防抖时间戳
         node.cleanupInterval = setInterval(function() {
             const now = Date.now();
@@ -130,10 +154,27 @@ module.exports = function(RED) {
             
             // 清理过期的窗帘运动状态
             for (const key in node.coverMoving) {
-                if (now - node.coverMoving[key].timestamp > COVER_LOOP_PREVENTION_MS) {
+                if (now - node.coverMoving[key].startTime > COVER_LOOP_PREVENTION_MS) {
                     delete node.coverMoving[key];
                 }
             }
+            
+            // 清理过期的调光运动状态
+            for (const key in node.brightnessMoving) {
+                if (now - node.brightnessMoving[key].startTime > LOOP_PREVENTION_MS) {
+                    delete node.brightnessMoving[key];
+                }
+            }
+            
+            // 尝试重新获取gateway（如果之前没有）
+            if (!gateway && node.mqttNode && node.mqttNode.gateway) {
+                gateway = node.mqttNode.gateway;
+                if (gateway) {
+                    node.log('[HA同步] 网关已就绪，注册设备状态监听');
+                    gateway.on('device-state-changed', node.handleSymiStateChange);
+                    node.status({ fill: 'green', shape: 'dot', text: `运行中 (${node.mappings.length}组)` });
+                }
+            }
         }, CLEANUP_INTERVAL_MS);
 
         // 防死循环检查 - 双向时间戳检查
@@ -367,14 +408,47 @@ module.exports = function(RED) {
             return { type: 'switch', value: isOn };
         };
 
-        // 处理亮度变化
+        // 处理亮度变化（带防抖，避免步进过程干扰）
         node.handleBrightnessChange = function(device, mapping, state) {
             const brightness = state.brightness !== undefined ? state.brightness : device.state.brightness;
             if (brightness === undefined) return null;
             
+            const loopKey = `${mapping.symiMac}_${mapping.symiKey}_${mapping.haEntityId}`;
+            
+            // 检查是否是HA发起的调光，如果是则忽略Mesh的亮度反馈（步进码）
+            if (node.brightnessMoving && node.brightnessMoving[loopKey]) {
+                const elapsed = Date.now() - node.brightnessMoving[loopKey].startTime;
+                if (elapsed < LOOP_PREVENTION_MS) {
+                    node.debug(`[Symi->HA] 亮度忽略(HA发起调光中): ${loopKey}`);
+                    return null;
+                } else {
+                    delete node.brightnessMoving[loopKey];
+                }
+            }
+            
+            // 防抖处理：取消之前的定时器，设置新的
+            const debounceKey = `brightness_${mapping.symiMac}_${mapping.symiKey}`;
+            if (node.pendingDebounce[debounceKey]) {
+                clearTimeout(node.pendingDebounce[debounceKey]);
+            }
+            
             // Mesh亮度0-100，HA亮度0-255
             const haBrightness = Math.round(brightness * 255 / 100);
-            return { type: 'brightness', value: haBrightness, meshValue: brightness };
+            
+            // 延迟同步，等待亮度稳定（过滤步进过程）
+            node.pendingDebounce[debounceKey] = setTimeout(() => {
+                delete node.pendingDebounce[debounceKey];
+                
+                node.queueCommand({
+                    direction: 'symi-to-ha',
+                    mapping: mapping,
+                    syncData: { type: 'brightness', value: haBrightness, meshValue: brightness },
+                    key: loopKey,
+                    skipLoopCheck: true
+                });
+            }, BRIGHTNESS_DEBOUNCE_MS);
+            
+            return null;  // 不立即同步，由定时器处理
         };
 
         // 处理窗帘变化（带防抖，避免步进反馈干扰）
@@ -466,46 +540,157 @@ module.exports = function(RED) {
             return { type: 'hvac_mode', value: haMode, meshValue: mode };
         };
 
-        // 监听网关事件
-        gateway.on('device-state-changed', node.handleSymiStateChange);
+        // 监听网关事件（如果gateway可用）
+        if (gateway) {
+            gateway.on('device-state-changed', node.handleSymiStateChange);
+        }
 
         // ========== 2. 监听HA状态变化 (HA -> Symi) ==========
         
-        // 方式A: 通过Input输入 (server-state-changed节点)
+        // 方式A: 通过Input输入 (支持多种HA节点格式)
         node.on('input', function(msg) {
-            if (msg.payload && (msg.payload.entity_id || (msg.data && msg.data.entity_id))) {
-                const entityId = msg.payload.entity_id || msg.data.entity_id;
-                const newState = msg.payload.new_state || msg.data.new_state;
-                const oldState = msg.payload.old_state || msg.data.old_state;
-                
-                if (entityId && newState) {
-                    node.handleHaStateChange(entityId, newState, oldState);
+            // 首次收到HA输入时更新状态
+            if (!node.haInputReceived) {
+                node.haInputReceived = true;
+                node.updateStatus();
+                node.log('[HA同步] 已收到HA输入，双向同步已启用');
+            }
+            
+            // 支持多种消息格式
+            let entityId, newState, oldState;
+            
+            // 格式1: server-events 节点格式 (msg.payload.event_type + msg.payload.event)
+            // 实际格式: { event_type: "state_changed", entity_id: "...", event: { entity_id, new_state, old_state } }
+            if (msg.payload && msg.payload.event_type === 'state_changed') {
+                entityId = msg.payload.entity_id;
+                // event 直接包含 new_state 和 old_state（不是 event.data）
+                if (msg.payload.event) {
+                    newState = msg.payload.event.new_state;
+                    oldState = msg.payload.event.old_state;
                 }
-            } else if (msg.data && msg.data.entity_id && msg.data.new_state) {
-                // 兼容旧格式
-                node.handleHaStateChange(msg.data.entity_id, msg.data.new_state, msg.data.old_state);
             }
+            // 格式2: server-state-changed 节点的标准格式 (msg.data)
+            else if (msg.data && msg.data.entity_id) {
+                entityId = msg.data.entity_id;
+                newState = msg.data.new_state;
+                oldState = msg.data.old_state;
+            }
+            // 格式3: payload 中直接包含 entity_id 和 new_state
+            else if (msg.payload && msg.payload.entity_id && msg.payload.new_state) {
+                entityId = msg.payload.entity_id;
+                newState = msg.payload.new_state;
+                oldState = msg.payload.old_state;
+            }
+            // 格式4: 直接的 event 数据 (msg.event)
+            else if (msg.event && msg.event.new_state) {
+                entityId = msg.event.entity_id;
+                newState = msg.event.new_state;
+                oldState = msg.event.old_state;
+            }
+            // 格式5: trigger: state 节点格式 (msg.payload 是状态对象)
+            else if (msg.payload && typeof msg.payload === 'object' && 
+                     msg.payload.state !== undefined && msg.payload.attributes !== undefined) {
+                entityId = msg.topic || msg.payload.entity_id;
+                newState = msg.payload;
+                oldState = null;
+            }
+            
+            // 过滤非 state_changed 事件和无效数据
+            if (!entityId || !newState) {
+                return;  // 静默忽略无法解析的消息
+            }
+            
+            // 过滤 event 类型的实体（如 event.xxx_click_e_xxx），这些不需要同步
+            if (entityId.startsWith('event.')) {
+                return;
+            }
+            
+            // 检查是否在映射列表中
+            const mappings = node.findMappingsByHa(entityId);
+            if (mappings.length === 0) {
+                return;  // 不在映射中的实体静默忽略
+            }
+            
+            // 只记录映射中的实体状态变化
+            node.log(`[HA->Symi] ${entityId}: ${oldState?.state || 'null'} -> ${newState.state}`);
+            node.handleHaStateChange(entityId, newState, oldState);
         });
         
-        // 方式B: 尝试订阅HA Server事件总线
-        if (node.haServer && node.haServer.eventBus) {
-            node.haEventHandler = (evt) => {
-                // node.debug(`[HA事件] type=${evt.event_type}, data=${JSON.stringify(evt.data)}`);
-                if (evt && evt.event_type === 'state_changed' && evt.data) {
-                    node.handleHaStateChange(evt.data.entity_id, evt.data.new_state, evt.data.old_state);
+        // 方式B: 尝试订阅HA Server事件总线 (备用方式，大多数情况不可用)
+        const subscribeToHaEvents = () => {
+            if (!node.haServer) {
+                // 静默处理，不显示警告
+                return;
+            }
+
+            // 尝试多种方式获取事件总线
+            let eventBus = null;
+            
+            // 方式1: 直接访问 eventBus
+            if (node.haServer.eventBus) {
+                eventBus = node.haServer.eventBus;
+            }
+            // 方式2: 通过 controller
+            else if (node.haServer.controller && node.haServer.controller.events) {
+                eventBus = node.haServer.controller.events;
+            }
+            // 方式3: 通过 websocket
+            else if (node.haServer.websocket && node.haServer.websocket.eventBus) {
+                eventBus = node.haServer.websocket.eventBus;
+            }
+            // 方式4: 检查 _events
+            else if (node.haServer._events) {
+                eventBus = node.haServer;
+            }
+
+            if (eventBus && typeof eventBus.on === 'function') {
+                // 防止重复订阅
+                if (node.haSubscribed) return;
+
+                node.haEventHandler = (evt) => {
+                    if (evt && evt.event_type === 'state_changed' && evt.data) {
+                        if (!node.haInputReceived) {
+                            node.haInputReceived = true;
+                            node.updateStatus();
+                        }
+                        node.handleHaStateChange(evt.data.entity_id, evt.data.new_state, evt.data.old_state);
+                    }
+                };
+                
+                // 尝试订阅不同的事件名
+                try {
+                    eventBus.on('ha_events:all', node.haEventHandler);
+                    node.haSubscribed = true;
+                    node.haInputReceived = true;
+                    node.log('[HA同步] 已成功订阅HA事件总线');
+                    node.updateStatus();
+                } catch (e1) {
+                    try {
+                        eventBus.on('state_changed', node.haEventHandler);
+                        node.haSubscribed = true;
+                        node.haInputReceived = true;
+                        node.log('[HA同步] 已成功订阅HA事件总线');
+                        node.updateStatus();
+                    } catch (e2) {
+                        // 静默失败
+                    }
                 }
-            };
-            node.haServer.eventBus.on('ha_events:all', node.haEventHandler);
-            node.log('[HA同步] 已订阅HA事件总线');
-        } else {
-            node.warn('[HA同步] 未能订阅HA事件总线，请确保HA节点配置正确且已连接');
-        }
+            }
+            // 事件总线不可用时不再重试，依赖 input 方式
+        };
+        
+        // 延迟启动订阅尝试，给HA服务器时间初始化
+        setTimeout(subscribeToHaEvents, 3000);
 
         node.handleHaStateChange = function(entityId, newState, oldState) {
-            if (!newState) return;
+            if (!newState) {
+                return;
+            }
             
             const mappings = node.findMappingsByHa(entityId);
-            if (mappings.length === 0) return;
+            if (mappings.length === 0) {
+                return;
+            }
             
             const domain = node.getEntityDomain(entityId);
             const attrs = newState.attributes || {};
@@ -545,6 +730,8 @@ module.exports = function(RED) {
                             if (!oldState || oldAttrs.brightness !== attrs.brightness) {
                                 // HA亮度0-255，Mesh亮度0-100
                                 const meshBrightness = Math.round(attrs.brightness * 100 / 255);
+                                // 标记HA发起的调光，防止Mesh步进反馈回传
+                                node.brightnessMoving[loopKey] = { direction: 'ha', startTime: Date.now() };
                                 syncDataList.push({ type: 'brightness', value: meshBrightness });
                             }
                         }
@@ -795,22 +982,6 @@ module.exports = function(RED) {
                 
                 node.log(`[Symi->HA] ${mapping.symiName || mapping.symiMac} -> ${mapping.haEntityId}: ${syncData.type}=${JSON.stringify(syncData.value)}`);
                 
-                // 仅输出到debug，不再重复send
-                /*
-                node.send({
-                    topic: 'ha-sync/symi-to-ha',
-                    payload: {
-                        direction: 'Symi→HA',
-                        symiMac: mapping.symiMac,
-                        symiKey: mapping.symiKey,
-                        haEntityId: mapping.haEntityId,
-                        syncType: syncData.type,
-                        value: syncData.value,
-                        timestamp: Date.now()
-                    }
-                });
-                */
-                
             } catch (err) {
                 node.error(`[Symi->HA] 调用失败: ${err.message}`);
             }
@@ -821,7 +992,14 @@ module.exports = function(RED) {
             const { mapping, syncData, key } = cmd;
             node.recordSyncTime('ha-to-symi', key);
             
-            const device = gateway.getDevice(mapping.symiMac);
+            // 动态获取gateway（可能在初始化后才可用）
+            const currentGateway = gateway || (node.mqttNode && node.mqttNode.gateway);
+            if (!currentGateway) {
+                node.warn(`[HA->Symi] 网关未就绪，无法控制设备`);
+                return;
+            }
+            
+            const device = currentGateway.getDevice(mapping.symiMac);
             if (!device) {
                 node.warn(`[HA->Symi] 设备未找到: ${mapping.symiMac}`);
                 return;
@@ -831,6 +1009,16 @@ module.exports = function(RED) {
             const channels = device.channels;
             const targetChannel = mapping.symiKey;
             
+            // 检查是否是三合一设备（symiKey为字符串类型）
+            const isThreeInOne = typeof targetChannel === 'string' && 
+                ['aircon', 'fresh_air', 'floor_heating'].includes(targetChannel);
+            
+            if (isThreeInOne) {
+                // 三合一设备使用专门的控制函数
+                await node.syncThreeInOne(cmd, device, networkAddr);
+                return;
+            }
+            
             try {
                 let attrType, param;
                 
@@ -877,27 +1065,10 @@ module.exports = function(RED) {
                         return;
                 }
                 
-                await gateway.sendControl(networkAddr, attrType, param);
+                await currentGateway.sendControl(networkAddr, attrType, param);
                 
                 node.log(`[HA->Symi] ${mapping.haEntityId} -> ${device.name || mapping.symiMac}: ${syncData.type}=${JSON.stringify(syncData.value)}`);
                 
-                // 仅输出到debug，不再重复send
-                /*
-                node.send({
-                    topic: 'ha-sync/ha-to-symi',
-                    payload: {
-                        direction: 'HA→Symi',
-                        haEntityId: mapping.haEntityId,
-                        symiMac: mapping.symiMac,
-                        symiKey: mapping.symiKey,
-                        syncType: syncData.type,
-                        value: syncData.value,
-                        attrType: attrType,
-                        timestamp: Date.now()
-                    }
-                });
-                */
-                
             } catch (err) {
                 node.error(`[HA->Symi] 控制失败: ${err.message}`);
             }
@@ -908,6 +1079,13 @@ module.exports = function(RED) {
             const { mapping, syncData } = cmd;
             const subType = mapping.symiKey;
             
+            // 动态获取gateway
+            const currentGateway = gateway || (node.mqttNode && node.mqttNode.gateway);
+            if (!currentGateway) {
+                node.warn(`[HA->Symi] 网关未就绪，无法控制三合一设备`);
+                return;
+            }
+            
             try {
                 let attrType, param;
                 
@@ -963,7 +1141,7 @@ module.exports = function(RED) {
                 }
                 
                 if (attrType && param) {
-                    await gateway.sendControl(networkAddr, attrType, param);
+                    await currentGateway.sendControl(networkAddr, attrType, param);
                     node.log(`[HA->Symi] ${mapping.haEntityId} -> ${mapping.symiName}(${subType}): ${syncData.type}=${JSON.stringify(syncData.value)}`);
                 }
                 
@@ -982,7 +1160,8 @@ module.exports = function(RED) {
                 clearTimeout(node.pendingDebounce[key]);
             }
             node.pendingDebounce = {};
-            node.coverMoving = {};  // 清理窗帘运动状态
+            node.coverMoving = {};       // 清理窗帘运动状态
+            node.brightnessMoving = {};  // 清理调光运动状态
             
             if (gateway) {
                 gateway.removeListener('device-state-changed', node.handleSymiStateChange);

package/nodes/symi-mqtt-sync.js

@@ -293,33 +293,86 @@ module.exports = function(RED) {
 
             let property = '', value = null;
             try {
-                if (fn === 1) {
-                    property = 'switch'; value = fv === 1;
-                    node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'switch', fv === 1);
-                } else if (fn === 2) {
-                    property = typeInfo.meshType === 'light' ? 'brightness' : 
-                               typeInfo.meshType === 'cover' ? 'position' : 'temperature';
-                    value = fv;
-                    node._gateway.deviceManager.controlDevice(meshMac, meshChannel, property, fv);
-                } else if (fn === 3) {
-                    if (typeInfo.meshType === 'climate') {
+                // 窗帘设备特殊处理 (typeId=14)
+                if (deviceType === 14) {
+                    if (fn === 1) {
+                        // fn=1: 窗帘动作控制 (fv: 0=关闭, 1=打开, 2=停止)
+                        if (fv === 1) {
+                            property = 'curtainAction'; value = 'open';
+                            node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'curtainAction', 'open');
+                        } else if (fv === 0) {
+                            property = 'curtainAction'; value = 'close';
+                            node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'curtainAction', 'close');
+                        } else if (fv === 2) {
+                            property = 'curtainAction'; value = 'stop';
+                            node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'curtainAction', 'stop');
+                        }
+                    } else if (fn === 2) {
+                        // fn=2: 窗帘位置 (fv: 0-100%)
+                        property = 'position'; value = fv;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'position', fv);
+                    }
+                }
+                // 灯具设备 (typeId=8)
+                else if (deviceType === 8) {
+                    if (fn === 1) {
+                        property = 'switch'; value = fv === 1;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'switch', fv === 1);
+                    } else if (fn === 2) {
+                        property = 'brightness'; value = fv;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'brightness', fv);
+                    }
+                }
+                // 空调设备 (typeId=12)
+                else if (deviceType === 12) {
+                    if (fn === 1) {
+                        property = 'switch'; value = fv === 1;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'switch', fv === 1);
+                    } else if (fn === 2) {
+                        property = 'temperature'; value = fv;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'temperature', fv);
+                    } else if (fn === 3) {
                         const mode = AC_MODE_MAP[fv];
                         if (mode) {
                             property = 'mode'; value = mode;
                             node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'mode', mode);
                         }
-                    } else if (typeInfo.meshType === 'fan') {
+                    } else if (fn === 4) {
+                        const speed = FAN_SPEED_MAP[fv];
+                        if (speed) {
+                            property = 'fanSpeed'; value = speed;
+                            node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'fanSpeed', speed);
+                        }
+                    }
+                }
+                // 地暖设备 (typeId=16)
+                else if (deviceType === 16) {
+                    if (fn === 1) {
+                        property = 'switch'; value = fv === 1;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'switch', fv === 1);
+                    } else if (fn === 2) {
+                        property = 'temperature'; value = fv;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'temperature', fv);
+                    }
+                }
+                // 新风设备 (typeId=36)
+                else if (deviceType === 36) {
+                    if (fn === 1) {
+                        property = 'switch'; value = fv === 1;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'switch', fv === 1);
+                    } else if (fn === 3) {
                         const speed = FAN_SPEED_MAP[fv];
                         if (speed) {
                             property = 'fanSpeed'; value = speed;
                             node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'fanSpeed', speed);
                         }
                     }
-                } else if (fn === 4 && typeInfo.meshType === 'climate') {
-                    const speed = FAN_SPEED_MAP[fv];
-                    if (speed) {
-                        property = 'fanSpeed'; value = speed;
-                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'fanSpeed', speed);
+                }
+                // 其他设备类型的通用处理
+                else {
+                    if (fn === 1) {
+                        property = 'switch'; value = fv === 1;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'switch', fv === 1);
                     }
                 }
                 
@@ -335,7 +388,9 @@ module.exports = function(RED) {
                         }
                     });
                 }
-            } catch (e) {}
+            } catch (e) {
+                node.warn(`[Brand→Mesh] 同步失败: ${e.message}`);
+            }
         }
 
         // ===== 同步到MQTT =====
@@ -353,18 +408,86 @@ module.exports = function(RED) {
             const typeInfo = node._brandProtocol.deviceTypes[deviceType];
             if (!typeInfo) return;
 
-            // 根据属性确定功能码
-            let fn;
-            if (property === 'switch' || property === 'on' || property === 'isOn') {
-                fn = 1;
-            } else if (property === 'brightness' || property === 'temperature' || property === 'position') {
-                fn = 2;
-            } else if (property === 'mode' || property === 'hvacMode') {
-                fn = 3;
-            } else if (property === 'fanSpeed' || property === 'fanMode') {
-                fn = typeInfo.meshType === 'climate' ? 4 : 3;
-            } else {
-                return;
+            // 根据设备类型和属性确定功能码
+            let fn, fv;
+            
+            // 窗帘设备特殊处理 (typeId=14)
+            if (deviceType === 14) {
+                if (property === 'curtainAction' || property === 'action') {
+                    fn = 1;
+                    if (value === 'open' || value === 1) fv = 1;
+                    else if (value === 'close' || value === 0) fv = 0;
+                    else if (value === 'stop' || value === 2) fv = 2;
+                    else return;
+                } else if (property === 'position' || property === 'curtainPosition') {
+                    fn = 2;
+                    fv = parseInt(value) || 0;
+                } else {
+                    return;
+                }
+            }
+            // 灯具设备 (typeId=8)
+            else if (deviceType === 8) {
+                if (property === 'switch' || property === 'on' || property === 'isOn') {
+                    fn = 1;
+                    fv = value ? 1 : 0;
+                } else if (property === 'brightness') {
+                    fn = 2;
+                    fv = parseInt(value) || 0;
+                } else {
+                    return;
+                }
+            }
+            // 空调设备 (typeId=12)
+            else if (deviceType === 12) {
+                if (property === 'switch' || property === 'on' || property === 'isOn') {
+                    fn = 1;
+                    fv = value ? 1 : 0;
+                } else if (property === 'temperature' || property === 'targetTemp') {
+                    fn = 2;
+                    fv = parseInt(value) || 24;
+                } else if (property === 'mode' || property === 'hvacMode' || property === 'climateMode') {
+                    fn = 3;
+                    fv = AC_MODE_REVERSE[value] ?? 0;
+                } else if (property === 'fanSpeed' || property === 'fanMode') {
+                    fn = 4;
+                    fv = FAN_SPEED_REVERSE[value] ?? 0;
+                } else {
+                    return;
+                }
+            }
+            // 地暖设备 (typeId=16)
+            else if (deviceType === 16) {
+                if (property === 'switch' || property === 'on' || property === 'isOn') {
+                    fn = 1;
+                    fv = value ? 1 : 0;
+                } else if (property === 'temperature' || property === 'targetTemp') {
+                    fn = 2;
+                    fv = parseInt(value) || 20;
+                } else {
+                    return;
+                }
+            }
+            // 新风设备 (typeId=36)
+            else if (deviceType === 36) {
+                if (property === 'switch' || property === 'on' || property === 'isOn') {
+                    fn = 1;
+                    fv = value ? 1 : 0;
+                } else if (property === 'fanSpeed' || property === 'fanMode') {
+                    fn = 3;
+                    fv = FAN_SPEED_REVERSE[value] ?? 0;
+                } else {
+                    return;
+                }
+            }
+            // 其他设备类型的通用处理
+            else {
+                if (property === 'switch' || property === 'on' || property === 'isOn') {
+                    fn = 1;
+                    fv = value ? 1 : 0;
+                } else {
+                    return;
+                }
             }
 
             // 防死循环 - 检查两个方向的时间戳
@@ -381,19 +504,6 @@ module.exports = function(RED) {
             node._syncTimestamps.set(meshSyncKey, now);
             node._syncTimestamps.set(mqttSyncKey, now);
 
-            let fv;
-            if (property === 'switch' || property === 'on' || property === 'isOn') {
-                fv = value ? 1 : 0;
-            } else if (property === 'brightness' || property === 'temperature' || property === 'position') {
-                fv = parseInt(value) || 0;
-            } else if (property === 'mode' || property === 'hvacMode') {
-                fv = AC_MODE_REVERSE[value] ?? 0;
-            } else if (property === 'fanSpeed' || property === 'fanMode') {
-                fv = FAN_SPEED_REVERSE[value] ?? 0;
-            } else {
-                return;
-            }
-
             const topic = node._brandProtocol.getDownTopic(node);
             const payload = node._brandProtocol.buildMessage(deviceType, deviceId, fn, fv);
 
@@ -410,7 +520,9 @@ module.exports = function(RED) {
                         timestamp: Date.now()
                     }
                 });
-            } catch (e) {}
+            } catch (e) {
+                node.warn(`[Mesh→Brand] 同步失败: ${e.message}`);
+            }
         }
 
         // ===== 网关事件监听 =====

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-symi-mesh",
-  "version": "1.8.1",
+  "version": "1.8.3",
   "description": "Node-RED节点集合，用于通过TCP/串口连接Symi蓝牙Mesh网关，支持Home Assistant MQTT Discovery自动发现和云端数据同步",
   "main": "nodes/symi-gateway.js",
   "scripts": {