怎么对接16A86型远程电源控制插座以实现场景联动电源控制_解决方案

CATALOG

[101224] 文档版本：V1.0 更新日期：2026年5月 适用对象：软件工程师、智能家居集成商、场景自动化开发者

第一章：场景联动电源控制需求与解决方案

1.1 场景联动电源控制的应用需求

在智能家居、智慧办公、共享空间等场景中，电源控制不再是孤立的通断操作，而是需要根据环境变化、时间计划、用户行为等条件自动联动响应。以下为典型联动场景：

联动场景	触发条件	预期动作	业务价值
人来灯亮/人走灯灭	人体传感器检测到有人/无人	自动开/关插座电源	节能降耗，体验便捷
温湿度联动空调	温度/湿度超过阈值	自动开启空调插座供电	环境舒适，自动调控
安防联动告警	门窗传感器检测到异常开启	自动接通报警器电源	安全保障，即时响应
定时场景切换	到达预设时间	执行批量插座开关	场景自动化，无需人工
远程一键控制	用户通过App点击	控制单个或批量插座	随时随地，便捷管理

1.2 解决方案：16A 86型远程电源插座 + 场景联动

芯步16A 86型智能墙壁插座通过标准HTTP接口开放控制能力，配合传感器设备和软件逻辑，可实现“条件触发-自动决策-精准控制”的场景联动闭环。

核心价值

标准86型安装：可直接平行替换原有16A墙壁插座，无需改造线路
高功率承载：额定16A/3500W，可接2匹空调、热水器等大功率设备
场景联动：支持HTTP接口调用，可自定义任意联动规则
私有化部署：支持纯局域网运行，响应更快、数据更安全

1.3 16A 86型远程电源插座核心参数

本方案产品详细参数如下

参数项	规格详情
产品型号	UNI-QC-16A（不带计量）/ UNI-QC-16A-P（带计量）
外形尺寸	86mm × 86mm × 31.1mm（标准86型）
安装方式	标准86型底盒安装，平行替换原有插座
插孔规格	1位3孔16A国标插座（可接2匹空调）
额定电流	MAX 16A
阻性负载功率	MAX 3500W（空调、热水器等）
感性负载功率	MAX 500W（电机、LED灯等）
工作电压	100-250V AC（交流/市电）
待机功耗	0.4W（断开）- 1W（接通/无负载）
无线连接	WiFi 2.4GHz IEEE 802.11 b/g/n
外壳材质	防火V0级PC，耐高温，符合安规标准
功率计量	带计量版本支持电压、电流、功率实时上报

版本对比

功能	UNI-QC-16A（不带计量）	UNI-QC-16A-P（带计量）
远程通断控制	✅ 支持	✅ 支持
延时通断（point/reset）	✅ 支持	✅ 支持
功率实时监测	❌ 不支持	✅ 支持
电压/电流上报	❌ 不支持	✅ 支持

选型：如需监测设备用电情况（如空调能耗统计），选择带计量版本。

第二章：HTTP接口协议详解

2.1 整体架构

芯步16A智能插座采用标准的HTTP请求-响应模型，适用于任何支持HTTP请求的编程语言，可无缝接入Web、小程序、管理后台等系统

graph LR
    subgraph 软件/联动层
        A[场景联动引擎/自动化规则]
    end
    
    subgraph 网络层
        B[芯步API网关]
    end
    
    subgraph 设备层
        C[16A墙壁插座]
        D[空调/热水器]
    end
    
    subgraph 触发源
        E[人体传感器]
        F[温湿度传感器]
        G[定时任务]
    end
    
    E -->|状态变化| A
    F -->|阈值触发| A
    G -->|时间到达| A
    A -->|HTTP POST| B
    B -->|MQTT透传| C
    C --> D

性能指标：从命令下发到设备实际响应，端到端延迟约为80-120ms。

2.2 请求地址与签名算法

请求地址

https://api.thingboot.com/{AppId}/device/control/?sign={sign}&ts={ts}

签名算法

Sign = md5( md5(AppSecret) + ts )

签名计算步骤

对 AppSecret 进行第一次 MD5 加密
将结果与时间戳 ts 拼接
对拼接后的字符串进行第二次 MD5 加密

Python示例

2.3 核心命令集

16A智能墙壁插座支持以下核心命令

命令类型	命令示例	说明	场景联动应用
电源开关	`{"power":"1"}`	开启插座电源	联动开灯/开空调
电源关闭	`{"power":"0"}`	关闭插座电源	人走断电/定时关
延时断电	`{"point":"30000"}`	通电30秒后自动断电	临时供电场景
延时通电	`{"reset":"5000"}`	断电5秒后自动通电	设备远程重启
状态查询	`{"get_status":""}`	查询插座通断状态	联动条件判断
计量查询	`{"metering":""}`	查询功率/电压/电流	能耗监测联动

point 命令说明：先通电，经指定时间（毫秒）后自动断电。例如 {"point":"3600000"} 表示通电1小时后自动关闭。常用于临时供电场景。

reset 命令说明：先断电，经指定时间（毫秒）后自动通电。常用于设备远程重启。

2.4 完整请求示例

第三章：场景联动设计

3.1 三层联动架构

场景联动电源控制采用触发源 → 规则引擎 → 执行器的三层架构：

graph TB
    subgraph 触发源
        A1[人体存在传感器]
        A2[温湿度传感器]
        A3[门窗传感器]
        A4[定时计划]
        A5[用户App操作]
    end
    
    subgraph 规则引擎
        B[场景联动服务]
        B1[条件判断]
        B2[规则匹配]
        B3[动作编排]
    end
    
    subgraph 执行层
        C1[16A插座-空调]
        C2[16A插座-热水器]
        C3[照明控制器]
        D[告警通知]
    end
    
    A1 --> B
    A2 --> B
    A3 --> B
    A4 --> B
    A5 --> B
    B --> C1
    B --> C2
    B --> C3
    B --> D

3.2 核心联动规则类型

联动类型	触发条件	执行动作	典型场景
传感器联动	传感器状态变化	开关插座电源	人来开空调、人走关空调
定时联动	到达预设时间	批量控制插座	下班自动断电、凌晨重启设备
阈值联动	数值超过阈值	开启/关闭电源	温度过高开空调、湿度过大开除湿
事件联动	设备状态变化	级联控制其他设备	安防触发接通报警器
用户联动	App手动触发	执行预设场景	一键离家模式

3.3 传感器联动支持

芯步提供多款传感器产品，可与16A插座实现联动

传感器类型	检测能力	联动
人体存在传感器	红外+雷达双模检测，5米范围	检测到有人时开启空调/灯光；无人持续N分钟后自动断电
温湿度传感器	温度、湿度实时监测	温度>28℃自动开启空调插座；湿度>75%自动开启除湿设备
门窗传感器	门/窗开合状态	门窗异常开启时接通报警器电源

第四章：多语言代码实现

4.1 Python完整实现

# -*- coding: utf-8 -*-
import hashlib
import time
import requests
import json
from typing import Dict, Optional, List
from datetime import datetime, time as dt_time
import threading
import schedule

# ========== 配置信息 ==========
APP_ID = "YOUR_APP_ID"
APP_SECRET = "YOUR_APP_SECRET"
DEVICE_ID = "YOUR_DEVICE_ID"      # 16A插座设备ID
API_BASE = "https://api.thingboot.com"
# =============================

def calculate_md5(s: str) -> str:
    return hashlib.md5(s.encode('utf-8')).hexdigest()

def send_command(order: dict, device_id: str = None) -> dict:
    """向设备发送命令"""
    ts = int(time.time())
    first_md5 = calculate_md5(APP_SECRET)
    sign_raw = first_md5 + str(ts)
    sign = calculate_md5(sign_raw)
    
    url = f"{API_BASE}/{APP_ID}/device/control/"
    params = {"sign": sign, "ts": ts}
    payload = {"device": device_id or DEVICE_ID, "order": order}
    
    try:
        response = requests.post(url, params=params, json=payload, timeout=5)
        return response.json() if response.ok else {"error": response.text}
    except Exception as e:
        return {"error": str(e)}

# ========== 插座基本控制 ==========
def power_on(device_id: str = None) -> dict:
    """开启插座电源"""
    return send_command({"power": "1"}, device_id)

def power_off(device_id: str = None) -> dict:
    """关闭插座电源"""
    return send_command({"power": "0"}, device_id)

def delay_off(delay_ms: int, device_id: str = None) -> dict:
    """
    延时断电:先通电，delay_ms毫秒后自动断电
    用于临时供电场景（如空调预热后关闭）
    """
    return send_command({"point": str(delay_ms)}, device_id)

def delay_on(delay_ms: int, device_id: str = None) -> dict:
    """
    延时通电:先断电，delay_ms毫秒后自动通电
    用于设备远程重启
    """
    return send_command({"reset": str(delay_ms)}, device_id)

def get_status(device_id: str = None) -> dict:
    """查询插座通断状态"""
    result = send_command({"get_status": ""}, device_id)
    if result.get("error"):
        return {"online": False, "is_on": None, "error": result["error"]}
    
    data = result.get("data", {})
    return {
        "online": data.get("online") == "1",
        "is_on": data.get("status") == "1",
        "raw": data
    }

def get_metering(device_id: str = None) -> dict:
    """获取计量数据（仅带计量版本支持）"""
    result = send_command({"metering": ""}, device_id)
    if result.get("error"):
        return {"error": result["error"]}
    
    data = result.get("data", {})
    return {
        "power_w": float(data.get("power", 0)),
        "voltage_v": float(data.get("voltage", 0)),
        "current_a": float(data.get("current", 0)),
        "online": data.get("online") == "1"
    }

# ========== 批量控制（多设备联动）==========
def batch_power_on(device_ids: List[str]) -> dict:
    """批量开启多个插座"""
    device_str = ",".join(device_ids)
    return send_command({"power": "1"}, device_str)

def batch_power_off(device_ids: List[str]) -> dict:
    """批量关闭多个插座"""
    device_str = ",".join(device_ids)
    return send_command({"power": "0"}, device_str)

# ========== 场景联动引擎 ==========

class SceneLinkageEngine:
    """场景联动规则引擎"""
    
    def __init__(self):
        self.rules = []           # 联动规则列表
        self.device_registry = {} # 设备注册表
        self.sensor_cache = {}    # 传感器状态缓存
    
    def register_device(self, device_id: str, device_name: str, device_type: str):
        """注册设备到联动系统"""
        self.device_registry[device_id] = {
            "name": device_name,
            "type": device_type,
            "last_status": None
        }
    
    def add_rule(self, rule: dict):
        """
        添加联动规则
        
        rule格式:
        {
            "name": "规则名称",
            "trigger": {"type": "sensor|timer|threshold", "condition": ...},
            "action": {"type": "power_on|power_off|delay", "target": "device_id", "params": {...}},
            "enabled": True
        }
        """
        self.rules.append(rule)
        print(f"[规则] 已添加: {rule['name']}")
    
    def on_sensor_event(self, sensor_id: str, event_type: str, event_data: dict):
        """处理传感器事件"""
        print(f"[传感器] {sensor_id} - {event_type}: {event_data}")
        
        # 匹配规则并执行
        for rule in self.rules:
            if not rule.get("enabled", True):
                continue
            
            trigger = rule.get("trigger", {})
            if trigger.get("type") == "sensor" and trigger.get("sensor_id") == sensor_id:
                if self._match_condition(trigger.get("condition"), event_data):
                    self._execute_action(rule.get("action"), rule["name"])
    
    def on_timer(self):
        """定时任务触发"""
        current_time = datetime.now()
        
        for rule in self.rules:
            if not rule.get("enabled", True):
                continue
            
            trigger = rule.get("trigger", {})
            if trigger.get("type") == "timer":
                exec_time = trigger.get("time")
                if current_time.strftime("%H:%M") == exec_time:
                    self._execute_action(rule.get("action"), rule["name"])
    
    def on_threshold_check(self):
        """阈值检查（定期执行）"""
        for rule in self.rules:
            if not rule.get("enabled", True):
                continue
            
            trigger = rule.get("trigger", {})
            if trigger.get("type") == "threshold":
                sensor_id = trigger.get("sensor_id")
                sensor_value = self.sensor_cache.get(sensor_id, {}).get("value")
                
                if sensor_value is not None:
                    condition = trigger.get("condition")
                    if self._check_threshold(sensor_value, condition):
                        self._execute_action(rule.get("action"), rule["name"])
    
    def update_sensor_value(self, sensor_id: str, value: float):
        """更新传感器数值"""
        self.sensor_cache[sensor_id] = {"value": value, "timestamp": datetime.now()}
    
    def _match_condition(self, condition: dict, event_data: dict) -> bool:
        """匹配条件"""
        if not condition:
            return True
        
        field = condition.get("field")
        operator = condition.get("operator")
        target = condition.get("value")
        
        actual = event_data.get(field)
        
        if operator == "==":
            return actual == target
        elif operator == "!=":
            return actual != target
        elif operator == ">":
            return actual > target
        elif operator == "<":
            return actual < target
        elif operator == "in":
            return actual in target
        
        return False
    
    def _check_threshold(self, value: float, condition: dict) -> bool:
        """检查阈值条件"""
        operator = condition.get("operator")
        threshold = condition.get("threshold")
        
        if operator == ">":
            return value > threshold
        elif operator == "<":
            return value < threshold
        elif operator == ">=":
            return value >= threshold
        elif operator == "<=":
            return value <= threshold
        return False
    
    def _execute_action(self, action: dict, rule_name: str):
        """执行联动动作"""
        action_type = action.get("type")
        target = action.get("target")
        params = action.get("params", {})
        
        print(f"[联动] 规则[{rule_name}] 触发，执行: {action_type} on {target}")
        
        if action_type == "power_on":
            power_on(target)
        elif action_type == "power_off":
            power_off(target)
        elif action_type == "delay_off":
            delay_ms = params.get("delay_ms", 30000)
            delay_off(delay_ms, target)
        elif action_type == "batch_power_on":
            batch_power_on(params.get("device_ids", []))
        elif action_type == "batch_power_off":
            batch_power_off(params.get("device_ids", []))
    
    def start(self):
        """启动联动引擎"""
        # 启动定时任务扫描
        def timer_scan():
            self.on_timer()
        
        def threshold_scan():
            self.on_threshold_check()
        
        schedule.every(1).minutes.do(timer_scan)
        schedule.every(30).seconds.do(threshold_scan)
        
        print("[引擎] 场景联动引擎已启动")
        
        while True:
            schedule.run_pending()
            time.sleep(1)

# ========== 场景联动配置示例 ==========

def setup_scene_rules(engine: SceneLinkageEngine):
    """配置场景联动规则"""
    
    # 规则1:人走灯灭/空调关
    engine.add_rule({
        "name": "人走关空调",
        "trigger": {
            "type": "sensor",
            "sensor_id": "human_sensor_01",
            "condition": {"field": "human_count", "operator": "==", "value": 0}
        },
        "action": {
            "type": "power_off",
            "target": "插座设备ID"
        },
        "enabled": True
    })
    
    # 规则2:温度过高自动开空调
    engine.add_rule({
        "name": "高温开空调",
        "trigger": {
            "type": "threshold",
            "sensor_id": "temp_sensor_01",
            "condition": {"operator": ">", "threshold": 28}
        },
        "action": {
            "type": "power_on",
            "target": "空调插座设备ID"
        },
        "enabled": True
    })
    
    # 规则3:下班自动断电
    engine.add_rule({
        "name": "下班断电",
        "trigger": {
            "type": "timer",
            "time": "18:00"
        },
        "action": {
            "type": "batch_power_off",
            "params": {"device_ids": ["插座1", "插座2", "插座3"]}
        },
        "enabled": True
    })
    
    # 规则4:安防联动
    engine.add_rule({
        "name": "门窗异常告警",
        "trigger": {
            "type": "sensor",
            "sensor_id": "door_sensor_01",
            "condition": {"field": "status", "operator": "==", "value": "open"}
        },
        "action": {
            "type": "power_on",
            "target": "报警器插座设备ID"
        },
        "enabled": True
    })

# ========== 调用示例 ==========
if __name__ == "__main__":
    # 示例1:基本控制
    # power_on()
    # power_off()
    
    # 示例2:延时断电（通电30秒后自动关闭）
    # delay_off(30000)
    
    # 示例3:查询状态
    # status = get_status()
    # print(f"插座状态: {'通电' if status['is_on'] else '断电'}")
    
    # 示例4:启动联动引擎
    # engine = SceneLinkageEngine()
    # engine.register_device("插座ID", "空调插座", "socket")
    # setup_scene_rules(engine)
    # engine.start()
    pass

4.2 Node.js实现

const crypto = require('crypto');
const axios = require('axios');
const schedule = require('node-schedule');

// 配置
const config = {
    appId: 'YOUR_APP_ID',
    appSecret: 'YOUR_APP_SECRET',
    deviceId: 'YOUR_DEVICE_ID',
    apiUrl: 'https://api.thingboot.com'
};

// 生成签名
function generateSign(secret, ts) {
    const firstMd5 = crypto.createHash('md5').update(secret).digest('hex');
    const signRaw = firstMd5 + ts;
    return crypto.createHash('md5').update(signRaw).digest('hex');
}

// 发送命令
async function sendCommand(order, deviceId = null) {
    const ts = Math.floor(Date.now() / 1000);
    const sign = generateSign(config.appSecret, ts);
    
    const url = `${config.apiUrl}/${config.appId}/device/control/`;
    const payload = { device: deviceId || config.deviceId, order };
    
    try {
        const response = await axios.post(url, payload, {
            params: { sign, ts },
            timeout: 5000
        });
        return response.data;
    } catch (error) {
        return { error: error.message };
    }
}

// 基本控制
async function powerOn(deviceId = null) {
    return sendCommand({ power: "1" }, deviceId);
}

async function powerOff(deviceId = null) {
    return sendCommand({ power: "0" }, deviceId);
}

async function delayOff(ms, deviceId = null) {
    return sendCommand({ point: String(ms) }, deviceId);
}

// 查询状态
async function getStatus(deviceId = null) {
    const result = await sendCommand({ get_status: "" }, deviceId);
    if (result.error) return { online: false, isOn: null };
    return {
        online: result.data?.online === '1',
        isOn: result.data?.status === '1'
    };
}

// 场景联动引擎
class SceneLinkageEngine {
    constructor() {
        this.rules = [];
    }
    
    addRule(rule) {
        this.rules.push(rule);
        console.log(`[规则] 已添加: ${rule.name}`);
    }
    
    async onTimer() {
        const now = new Date();
        const timeStr = `${now.getHours().toString().padStart(2,'0')}:${now.getMinutes().toString().padStart(2,'0')}`;
        
        for (const rule of this.rules) {
            if (!rule.enabled) continue;
            if (rule.trigger.type === 'timer' && rule.trigger.time === timeStr) {
                await this.executeAction(rule.action);
                console.log(`[联动] 定时规则触发: ${rule.name}`);
            }
        }
    }
    
    async executeAction(action) {
        if (action.type === 'power_on') {
            await powerOn(action.target);
        } else if (action.type === 'power_off') {
            await powerOff(action.target);
        } else if (action.type === 'delay_off') {
            await delayOff(action.params.delayMs, action.target);
        }
    }
    
    start() {
        // 每分钟检查定时规则
        schedule.scheduleJob('* * * * *', () => this.onTimer());
        console.log('[引擎] 场景联动引擎已启动');
    }
}

// 使用示例
// const engine = new SceneLinkageEngine();
// engine.addRule({
//     name: '下班断电',
//     enabled: true,
//     trigger: { type: 'timer', time: '18:00' },
//     action: { type: 'power_off', target: config.deviceId }
// });
// engine.start();

4.3 人体传感器联动配置

芯步人体存在传感器支持双模检测（红外+雷达），当检测到有人/无人状态变化时，可实时上报至您的服务器。

联动

传感器检测到状态变化
向您的服务器推送状态数据
服务器根据规则判断是否执行插座控制
调用插座API执行通断

传感器上报示例

联动处理代码

第五章：场景联动应用实例

5.1 第一种场景：人来开空调、人走关空调

需求：会议室/办公室内检测到有人时自动开启空调，无人时延时关闭。

实现的方式是：人体存在传感器 + 16A空调插座 + 联动规则

联动规则

触发：传感器检测到有人（human=1）
动作：开启空调插座电源
触发：传感器检测到无人（human=0）且持续30秒
动作：关闭空调插座电源

5.2 第二种场景：温度过高自动开空调

需求：夏季室温超过28℃时自动开启空调制冷。

实现的方式是：温湿度传感器 + 16A空调插座 + 阈值判断

联动规则

触发：温度 > 28℃
动作：开启空调插座电源
触发：温度 < 24℃
动作：关闭空调插座电源（节能）

5.3 第三种场景：下班自动断电（定时联动）

需求：每日18:00自动关闭办公室所有非必要电源。

实现的方式是：定时任务 + 批量控制

联动规则

触发：每日18:00
动作：批量关闭所有注册插座的电源

5.4 场景四：安防联动报警

需求：下班后门窗异常开启时，自动接通报警器电源并推送告警。

实现的方式是：门窗传感器 + 16A报警器插座 + 安防规则

联动规则

触发：门窗传感器状态=开启（且在非工作时间）
动作1：接通报警器插座电源
动作2：推送告警通知至管理员

5.5 场景五：设备远程重启（先断后通）

需求：摄像头/路由器死机时，远程断电重启。

实现的方式是：使用reset命令

命令示例

适用场景：摄像头、路由器、网关等网络设备死机恢复

第六章：部署与故障排查

6.1 安装与网络部署

部署要点	推荐方案	说明
安装方式	标准86型底盒安装	可直接平行替换原有插座
负载类型	阻性负载≤3500W，感性负载≤500W	LED灯/电机需降额使用
网络要求	2.4GHz WiFi	设备仅支持2.4GHz频段
供电电压	100-250V AC	全球市电兼容

6.2 常见问题排查

现象	可能原因	解决方案
设备离线	1. 电源断开2. WiFi密码错误/信号弱3. 路由器禁用了MAC	1. 检查供电2. 重新配网3. 检查路由器白名单
接口返回403	1. AppSecret错误2. 签名计算错误3. ts与服务端时间偏差>5分钟	1. 核对AppSecret2. 确认MD5为32位小写3. 同步NTP时间
控制成功但设备不工作	感性负载功率超限	检查负载功率≤500W
联动不触发	1. 规则配置错误2. 传感器上报未收到	1. 检查规则条件2. 检查消息推送配置

6.3 性能优化

本地联动优先：关键联动规则（如安防）在边缘网关执行，减少云端依赖
状态缓存：使用Redis缓存设备状态，减少重复API调用
批量控制：多设备联动时使用批量接口，减少网络开销

第七章：总结

通过将芯步16A 86型远程电源插座接入场景联动系统，可以构建“传感器感知 → 规则判断 → 插座执行”的智能化电源控制闭环。

核心要点回顾

硬件规格：16A/3500W、标准86型安装、可接空调等大功率设备
核心命令power（开关）、point（延时断电）、reset（延时通电/重启）
场景联动：支持传感器触发、定时任务、阈值判断等多种联动方式
开放集成：HTTP接口适用于任何编程语言，支持私有化部署
版本选择：带计量版本可监测功率，适合能耗管理场景

对接工作量评估：熟悉HTTP接口的开发者可在2小时内完成基本控制和联动规则配置。

预期收益

节能降耗：人走断电策略预计节约30%以上空调用电
提升体验：环境自动调节，无需人工干预
安全保障：异常事件即时联动，响应速度提升80%

第一章：场景联动电源控制需求与解决方案

1.1 场景联动电源控制的应用需求

1.2 解决方案：16A 86型远程电源插座 + 场景联动

1.3 16A 86型远程电源插座核心参数

第二章：HTTP接口协议详解

2.1 整体架构

2.2 请求地址与签名算法

2.3 核心命令集

2.4 完整请求示例

第三章：场景联动设计

3.1 三层联动架构

3.2 核心联动规则类型

3.3 传感器联动支持

第四章：多语言代码实现

4.1 Python完整实现

4.2 Node.js实现

4.3 人体传感器联动配置

第五章：场景联动应用实例

5.1 第一种场景：人来开空调、人走关空调

5.2 第二种场景：温度过高自动开空调

5.3 第三种场景：下班自动断电（定时联动）

5.4 场景四：安防联动报警

5.5 场景五：设备远程重启（先断后通）

第六章：部署与故障排查

6.1 安装与网络部署

6.2 常见问题排查

6.3 性能优化

第七章：总结

插座产品方案：

景观亮化设备电源控制：怎么将10A86型智能电源控制插座接入到项目中

园区设备电源控制：如何将1位5孔定时开关插座接入到软件项目中

怎样在医院设备电源管理中对接智能设备以实现手机 APP 远程遥控

如何对接10A86型远程控制插座来实现故障告警通知

怎样在智能办公设备电源控制中接入智能硬件来实现空调电源控制

联动场景方案：

如何二次开发壁挂式智能感应控制器来实现语音设备联动警示

弱电间人体感应联动：怎样把吸顶式高精度红外传感器对接到项目中

如何在门店灯光管理中集成智能硬件来实现灯光场景联动控制

怎样在活动现场人体感应与火灾预警中接入智能设备以实现消防预警联动

如何接入8路包间综合管理控制器以实现包间消费时长电源联动

场景用途方案：

怎么二次开发一路门禁一路照明开关来实现场景联动照明门禁控制

如何在门店灯光管理中集成智能硬件来实现灯光场景联动控制

如何对接50A带计量数显智能断路器以实现场景联动控制

怎么在共享棋牌室氛围灯光控制场景中对接智能设备以实现自定义灯光场景模板设置

怎么接入2路智能墙壁开关以实现场景联动照明门禁控制