自助洗车设备远程控制场景：如何将10A86型WiFi智能插座接入到自己的项目中_解决方案

CATALOG

[2173] 文档版本：V1.0 更新日期：2026年5月 适用对象：软件工程师、物联网集成商、自助洗车运营方

第一章：自助洗车场景痛点与解决概述

1.1 自助洗车设备管理的运营挑战

在无人值守自助洗车场景中，洗车机、泡沫机、吸尘器、烘干机等设备的电源控制是实现自助服务和远程运维的关键环节。传统管理方式面临以下痛点：

痛点	具体表现	带来的影响
人工依赖强	设备开关需现场操作	无法实现24小时无人值守运营
状态不可知	设备是否正常供电无法远程确认	故障发现滞后，影响用户体验
能耗无法统计	设备实际用电量无数据	运营成本核算困难
故障响应慢	设备死机/异常需到场断电重启	停机时间长，收益损失

1.2 解决方案：10A 86型WiFi智能插座实现远程设备控制

芯步10A 86型WiFi智能插座通过标准HTTP接口与自助洗车管理平台对接，实现“用户扫码支付-设备自动通电-计时计费-时间到自动断电”的完整自助服务闭环。

核心价值

标准86型安装：可直接替换原有墙壁插座，改造成本低
开放HTTP接口：适用于任何支持HTTP请求的编程语言，无缝对接洗车管理软件
毫秒级响应：80-120ms端到端延迟，用户体验流畅
功率计量可选：带计量版本可实时监测设备用电情况
私有化部署：支持纯局域网运行，数据不出场地

1.3 10A 86型智能墙壁插座核心参数

本方案产品详细参数如下

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

1.4 自助洗车设备选型

洗车设备类型	典型功率	是否适用	注意事项
高压洗车机	1500-2200W	✅ 适用	电机类负载，功率控制在2200W内
泡沫机	100-300W	✅ 适用	感性负载，启动电流较大
吸尘器	1000-2000W	✅ 适用	需确认启动功率不超限
烘干机	1500-2200W	✅ 适用	阻性负载，可满载使用
大型空压机	>2200W	❌ 不适用	需选用16A版本

⚠️ 重要提示：洗车设备普遍采用电机作为动力，属于感性负载，启动电流可达额定电流的5-7倍，每路功率控制在300W以内或选用16A版本。

第二章：HTTP接口协议详解

2.1 整体架构

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

graph LR
    subgraph 用户端
        A[洗车小程序/APP]
    end
    
    subgraph 软件层
        B[洗车管理平台]
    end
    
    subgraph 网络层
        C[芯步API网关
api.thingboot.com]
    end
    
    subgraph 硬件层
        D[10A智能墙壁插座]
        E[洗车机/吸尘器等]
    end
    
    A -->|扫码支付| B
    B -->|HTTP POST| C
    C -->|MQTT透传| D
    D -->|通电| E

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

2.2 请求地址格式

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

URL参数说明

参数	说明	示例
`{AppId}`	应用ID，在芯步控制台获取	`10001`
`sign`	动态签名，验证请求合法性	`a1b2c3d4...`
`ts`	当前Unix时间戳（秒级）	`1746000000`

2.3 签名算法（核心安全机制）

芯步API采用双重MD5签名机制，确保接口调用的安全性

Sign = md5( md5(AppSecret) + ts )

签名计算步骤

flowchart LR
    A[AppSecret] --> B[MD5加密]
    B --> C[32位小写: md5_secret]
    C --> D[拼接ts: md5_secret + ts]
    D --> E[再次MD5加密]
    E --> F[最终Sign]

Python示例

安全要点

两次MD5输出均为32位小写十六进制字符串
ts需与服务端时间同步，误差不超过5分钟
如仅测试对接，可在控制台开启“调试模式”，此时不检查sign和ts

2.4 核心命令集

同品类设备命令格式相同或相近，智能插座支持以下核心命令

命令类别	命令示例	说明
接通电源	`{"power":"1"}`	插座通电，设备启动
断开电源	`{"power":"0"}`	插座断电，设备停止
延时断开	`{"point":"30000"}`	通电后定时断开（毫秒）
延时接通	`{"reset":"5000"}`	断电后定时接通（重启）
状态查询	`{"get_status":""}`	查询通断状态和在线状态
计量查询	`{"metering":""}`	查询电压、电流、功率（仅计量版）

2.5 完整请求示例

响应时间：从命令下发到设备响应约为80-120ms。

第三章：多语言代码实现

3.1 Python完整实现

# -*- coding: utf-8 -*-
import hashlib
import time
import requests
import json
from typing import Dict, Optional
from datetime import datetime, timedelta
import threading

# ========== 配置信息 ==========
APP_ID = "YOUR_APP_ID"           # 应用ID
APP_SECRET = "YOUR_APP_SECRET"   # 应用密钥
DEVICE_ID = "YOUR_DEVICE_ID"     # 智能插座设备ID
API_BASE = "https://api.thingboot.com"
# =============================

def calculate_md5(s: str) -> str:
    """计算MD5（32位小写）"""
    return hashlib.md5(s.encode('utf-8')).hexdigest()

def send_command(order: dict) -> dict:
    """向设备发送命令"""
    ts = int(time.time())
    md5_secret = calculate_md5(APP_SECRET)
    sign_raw = md5_secret + str(ts)
    sign = calculate_md5(sign_raw)
    
    url = f"{API_BASE}/{APP_ID}/device/control/"
    params = {"sign": sign, "ts": ts}
    payload = {"device": 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() -> dict:
    """接通电源，设备启动"""
    return send_command({"power": "1"})

def power_off() -> dict:
    """断开电源，设备停止"""
    return send_command({"power": "0"})

def delay_off(delay_ms: int) -> dict:
    """
    延时断开:通电后指定毫秒自动断电
    
    参数:
        delay_ms: 延时毫秒数（如30000=30秒）
    """
    return send_command({"point": str(delay_ms)})

def delay_on(delay_ms: int) -> dict:
    """
    延时接通:断电后指定毫秒自动通电（重启功能）
    
    参数:
        delay_ms: 延时毫秒数
    """
    return send_command({"reset": str(delay_ms)})

def reset_device(delay_ms: int = 5000) -> dict:
    """
    远程重启设备（先断后通）
    
    参数:
        delay_ms: 断电时长（毫秒），默认5秒
    """
    return send_command({"reset": str(delay_ms)})

def get_status() -> dict:
    """查询设备状态（通断状态+在线状态）"""
    return send_command({"get_status": ""})

def is_power_on() -> Optional[bool]:
    """查询当前是否通电"""
    result = get_status()
    if result.get("error"):
        return None
    return result.get("data", {}).get("status") == "1"

def is_online() -> bool:
    """检查设备是否在线"""
    result = get_status()
    if result.get("error"):
        return False
    return result.get("data", {}).get("online") == "1"

# ========== 计量功能（带计量版本） ==========

def get_metering_data() -> Dict:
    """
    获取计量数据（仅带功率计量版本支持）
    
    返回:
        {
            "power": float,     # 当前功率(W)
            "voltage": float,   # 当前电压(V)
            "current": float,   # 当前电流(A)
            "online": bool
        }
    """
    result = send_command({"metering": ""})
    
    if result.get("error"):
        return {"error": result["error"], "online": False}
    
    data = result.get("data", {})
    return {
        "power": float(data.get("power", 0)),
        "voltage": float(data.get("voltage", 0)),
        "current": float(data.get("current", 0)),
        "online": data.get("online") == "1"
    }

# ========== 自助洗车业务场景 ==========

class CarWashController:
    """自助洗车设备控制器"""
    
    def __init__(self, device_id: str, equipment_name: str, price_per_minute: float = 1.0):
        """
        初始化
        
        参数:
            device_id: 插座设备ID
            equipment_name: 设备名称（洗车机/吸尘器等）
            price_per_minute: 每分钟价格（元）
        """
        self.device_id = device_id
        self.equipment_name = equipment_name
        self.price_per_minute = price_per_minute
        self.active_orders = {}  # {order_id: {"start_time": datetime, "duration": int}}
    
    def start_session(self, order_id: str, duration_minutes: int) -> dict:
        """
        开始洗车会话:通电并计时
        
        参数:
            order_id: 订单ID
            duration_minutes: 使用时长（分钟）
        """
        # 1. 通电启动设备
        result = power_on()
        if result.get("error"):
            return {"success": False, "error": f"设备通电失败: {result['error']}"}
        
        # 2. 记录会话信息
        self.active_orders[order_id] = {
            "start_time": datetime.now(),
            "duration": duration_minutes,
            "equipment": self.equipment_name
        }
        
        # 3. 设置定时断电（使用延时指令）
        delay_ms = duration_minutes * 60 * 1000
        delay_off(delay_ms)
        
        print(f"[会话开始] {order_id} - {self.equipment_name} 已启动，可用{duration_minutes}分钟")
        
        return {
            "success": True,
            "order_id": order_id,
            "equipment": self.equipment_name,
            "duration_minutes": duration_minutes,
            "start_time": datetime.now().isoformat(),
            "auto_off_at": (datetime.now() + timedelta(minutes=duration_minutes)).isoformat()
        }
    
    def end_session(self, order_id: str) -> dict:
        """
        提前结束会话:立即断电
        
        参数:
            order_id: 订单ID
        """
        if order_id not in self.active_orders:
            return {"success": False, "error": "会话不存在或已结束"}
        
        session = self.active_orders[order_id]
        actual_duration = (datetime.now() - session["start_time"]).total_seconds() / 60
        cost = actual_duration * self.price_per_minute
        
        # 断电
        power_off()
        
        # 清除会话记录
        del self.active_orders[order_id]
        
        print(f"[会话结束] {order_id} - 实际使用{actual_duration:.1f}分钟，费用{cost:.2f}元")
        
        return {
            "success": True,
            "order_id": order_id,
            "actual_duration_minutes": round(actual_duration, 1),
            "cost_yuan": round(cost, 2)
        }
    
    def get_session_status(self, order_id: str) -> dict:
        """查询当前会话状态"""
        if order_id not in self.active_orders:
            return {"active": False}
        
        session = self.active_orders[order_id]
        elapsed = (datetime.now() - session["start_time"]).total_seconds() / 60
        remaining = session["duration"] - elapsed
        
        return {
            "active": True,
            "equipment": self.equipment_name,
            "elapsed_minutes": round(elapsed, 1),
            "remaining_minutes": round(max(0, remaining), 1)
        }
    
    def emergency_stop(self) -> dict:
        """紧急停止:立即断电所有设备"""
        result = power_off()
        
        # 清空所有会话
        self.active_orders.clear()
        
        return {"success": not result.get("error"), "action": "emergency_stop"}

# ========== 集成功率监测 ==========

class PowerMonitor:
    """设备功率监测（用于判断设备是否正常运行）"""
    
    def __init__(self, expected_power_range: tuple = (500, 2200)):
        """
        参数:
            expected_power_range: 正常功率范围(W) (min, max)
        """
        self.expected_min, self.expected_max = expected_power_range
    
    def check_device_health(self) -> dict:
        """检查设备运行状态"""
        data = get_metering_data()
        
        if not data.get("online"):
            return {"healthy": False, "reason": "设备离线"}
        
        power = data.get("power", 0)
        
        if power == 0:
            return {"healthy": False, "reason": "设备未通电或已关机"}
        elif power < self.expected_min:
            return {"healthy": False, "reason": f"功率过低: {power}W < {self.expected_min}W"}
        elif power > self.expected_max:
            return {"healthy": False, "reason": f"功率过高: {power}W > {self.expected_max}W"}
        else:
            return {"healthy": True, "power_w": power, "voltage_v": data.get("voltage")}
    
    def get_energy_consumption(self, duration_minutes: float) -> float:
        """估算指定时长的用电量（kWh）"""
        data = get_metering_data()
        power_kw = data.get("power", 0) / 1000
        hours = duration_minutes / 60
        return round(power_kw * hours, 3)

# ========== 调用示例 ==========
if __name__ == "__main__":
    # 初始化洗车机控制器
    carwash = CarWashController(DEVICE_ID, "高压洗车机", price_per_minute=1.5)
    
    # 示例:开始洗车会话（10分钟）
    # result = carwash.start_session("ORD2024001", 10)
    # print(f"会话开始: {result}")
    
    # 示例:查询会话状态
    # status = carwash.get_session_status("ORD2024001")
    # print(f"会话状态: {status}")
    
    # 示例:提前结束
    # end_result = carwash.end_session("ORD2024001")
    # print(f"会话结束: {end_result}")
    
    # 示例:计量数据查询（需计量版）
    # meter = get_metering_data()
    # print(f"当前功率: {meter.get('power')}W")

3.2 Node.js实现

const crypto = require('crypto');
const axios = require('axios');

// 配置
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) {
    const ts = Math.floor(Date.now() / 1000);
    const sign = generateSign(config.appSecret, ts);
    
    const url = `${config.apiUrl}/${config.appId}/device/control/`;
    const payload = { device: 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() {
    return sendCommand({ power: "1" });
}

// 断电
async function powerOff() {
    return sendCommand({ power: "0" });
}

// 延时断电
async function delayOff(ms) {
    return sendCommand({ point: String(ms) });
}

// 查询状态
async function getStatus() {
    return sendCommand({ get_status: "" });
}

// 洗车会话管理
class CarWashSession {
    constructor(deviceId, equipmentName) {
        this.deviceId = deviceId;
        this.equipmentName = equipmentName;
        this.activeSessions = new Map();
    }
    
    async startSession(orderId, durationMinutes) {
        // 通电
        const result = await powerOn();
        if (result.error) {
            return { success: false, error: result.error };
        }
        
        // 记录会话
        this.activeSessions.set(orderId, {
            startTime: new Date(),
            duration: durationMinutes
        });
        
        // 设置定时断电
        const delayMs = durationMinutes * 60 * 1000;
        await delayOff(delayMs);
        
        return {
            success: true,
            orderId: orderId,
            equipment: this.equipmentName,
            durationMinutes: durationMinutes,
            startTime: new Date().toISOString()
        };
    }
    
    async endSession(orderId) {
        const session = this.activeSessions.get(orderId);
        if (!session) {
            return { success: false, error: '会话不存在' };
        }
        
        // 立即断电
        await powerOff();
        
        // 计算实际时长
        const elapsed = (new Date() - session.startTime) / 60000;
        this.activeSessions.delete(orderId);
        
        return {
            success: true,
            orderId: orderId,
            actualMinutes: elapsed.toFixed(1)
        };
    }
}

// 使用示例
// const washer = new CarWashSession(config.deviceId, '高压洗车机');
// washer.startSession('ORD001', 10).then(console.log);

3.3 Java实现

import java.security.MessageDigest;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Instant;

public class SmartPlugController {
    private static final String APP_ID = "YOUR_APP_ID";
    private static final String APP_SECRET = "YOUR_APP_SECRET";
    private static final String DEVICE_ID = "YOUR_DEVICE_ID";
    private static final String API_BASE = "https://api.thingboot.com";
    
    private static String md5(String input) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] digest = md.digest(input.getBytes());
            StringBuilder sb = new StringBuilder();
            for (byte b : digest) {
                sb.append(String.format("x", b));
            }
            return sb.toString();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    private static String generateSign(long ts) {
        String firstMd5 = md5(APP_SECRET);
        String signRaw = firstMd5 + ts;
        return md5(signRaw);
    }
    
    public static String powerOn() throws Exception {
        long ts = Instant.now().getEpochSecond();
        String sign = generateSign(ts);
        
        String url = String.format("%s/%s/device/control/?sign=%s&ts=%d",
            API_BASE, APP_ID, sign, ts);
        
        String jsonBody = String.format(
            "{\"device\":\"%s\",\"order\":{\"power\":\"1\"}}",
            DEVICE_ID
        );
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();
        
        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());
        return response.body();
    }
    
    public static String powerOff() throws Exception {
        long ts = Instant.now().getEpochSecond();
        String sign = generateSign(ts);
        
        String url = String.format("%s/%s/device/control/?sign=%s&ts=%d",
            API_BASE, APP_ID, sign, ts);
        
        String jsonBody = String.format(
            "{\"device\":\"%s\",\"order\":{\"power\":\"0\"}}",
            DEVICE_ID
        );
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();
        
        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());
        return response.body();
    }
    
    public static void main(String[] args) throws Exception {
        // 开启设备
        powerOn();
        System.out.println("洗车设备已启动");
        
        // 等待30秒后自动断电（示例）
        // Thread.sleep(30000);
        // powerOff();
    }
}

3.4 Shell脚本（cURL）实现

第四章：自助洗车业务场景集成

4.1 系统集成架构

自助洗车设备远程控制系统可与用户端小程序、运营后台深度集成

graph TB
    subgraph 用户端
        A[用户扫码]
        B[支付/选择时长]
        C[开始使用]
    end
    
    subgraph 平台层
        D[洗车管理平台]
        D1[订单管理]
        D2[设备控制]
        D3[计时计费]
    end
    
    subgraph 设备层
        E[芯步API网关]
        F[智能墙壁插座]
        G[洗车机/吸尘器]
    end
    
    subgraph 运维端
        H[运营后台]
        I[故障告警]
    end
    
    A --> B
    B --> D1
    D1 --> D2
    D2 --> E
    E --> F
    F --> G
    D2 --> H
    D1 --> I

4.2 第一种场景：用户扫码支付自动通电

业务需求：用户扫描洗车机二维码，支付成功后自动通电启动设备。

实现逻辑

用户扫码获取设备ID
选择使用时长并支付
支付成功后系统调用API通电
开始计时，计时结束自动断电
按实际使用时长扣费

代码实现

4.3 第二种场景：使用时长计费与自动断电

业务需求：系统按实际使用时长计费，时间到自动断电。

实现逻辑

记录用户开始使用时间
设置断电定时器（使用设备硬延时或软件定时）
用户提前结束或时间到触发断电
计算费用并完成扣款

代码实现

4.4 第三种场景：设备离线/异常告警

业务需求：插座设备离线或功率异常时，自动通知运维人员。

实现逻辑

定时轮询设备在线状态
检测到离线触发告警
带计量版本可检测功率异常（空转/过载）

代码实现

def monitor_carwash_devices(device_list: list):
    """定期巡检洗车设备状态"""
    for device in device_list:
        # 查询设备状态
        status = get_status(device["device_id"])
        
        if not is_online(device["device_id"]):
            # 设备离线告警
            send_alert({
                "type": "offline",
                "device_id": device["device_id"],
                "location": device["location"],
                "time": datetime.now().isoformat()
            })
        
        # 带计量版本:检测功率异常
        if device.get("has_metering"):
            meter = get_metering_data(device["device_id"])
            power = meter.get("power", 0)
            
            # 设备应运行但功率为0
            if device.get("should_be_running") and power == 0:
                send_alert({
                    "type": "no_power",
                    "device_id": device["device_id"],
                    "location": device["location"]
                })
            
            # 功率异常高（可能过载）
            if power > 2500:
                # 自动断电保护
                power_off(device["device_id"])
                send_alert({
                    "type": "overload",
                    "device_id": device["device_id"],
                    "power": power
                })

def send_alert(alert_info: dict):
    """发送告警通知"""
    # 实际项目中可集成短信、邮件、钉钉等
    print(f"[告警] {alert_info}")

4.5 场景四：设备远程重启（故障恢复）

业务需求：洗车机偶尔死机，可通过远程断电重启恢复。

实现逻辑

运营人员后台点击"重启"按钮
系统下发reset命令
设备断电x秒后自动恢复通电
记录重启操作日志

代码实现

4.6 场景五：用户实时查询剩余时间

业务需求：用户在洗车过程中可实时查看剩余使用时间。

代码实现

第五章：部署与最佳实践

5.1 自助洗车场景部署

部署要点	推荐方案	说明
安装方式	标准86型底盒安装	可直接替换原有插座
安装位置	洗车机旁防水盒内	避免水溅
版本选择	带功率计量版	可监测设备运行状态
WiFi要求	2.4GHz频段	设备仅支持2.4GHz
防水保护

第一章：自助洗车场景痛点与解决概述

1.1 自助洗车设备管理的运营挑战

1.2 解决方案：10A 86型WiFi智能插座实现远程设备控制

1.3 10A 86型智能墙壁插座核心参数

1.4 自助洗车设备选型

第二章：HTTP接口协议详解

2.1 整体架构

2.2 请求地址格式

2.3 签名算法（核心安全机制）

2.4 核心命令集

2.5 完整请求示例

第三章：多语言代码实现

3.1 Python完整实现

3.2 Node.js实现

3.3 Java实现

3.4 Shell脚本（cURL）实现

第四章：自助洗车业务场景集成

4.1 系统集成架构

4.2 第一种场景：用户扫码支付自动通电

4.3 第二种场景：使用时长计费与自动断电

4.4 第三种场景：设备离线/异常告警

4.5 场景四：设备远程重启（故障恢复）

4.6 场景五：用户实时查询剩余时间

第五章：部署与最佳实践

5.1 自助洗车场景部署

插座产品方案：

景观亮化设备电源控制：怎样将10A86型定时开关插座对接到项目中

怎样在出租屋用电安全管理中集成智能硬件以实现远程控制大功率电器电源

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

如何在图书馆设备电源控制中接入智能设备以实现定时开关电器设备

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

自助洗车场景方案：

怎么在自助洗车设备小型语音播报场景中集成智能设备以实现远程音量调节控制

自助洗车设备电源控制：如何将35A智能限流断路器接入到自己的项目中

自助洗车设备电源控制：如何把35A定时控制断路器对接到自己的项目中

自助洗车设备电源管理：怎么将16A定时智能插座对接到软件项目中

自助洗车设备电源控制：如何把50A智能电源控制断路器对接到自己的项目中

远程用途方案：

如何对接60A智能电源控制断路器来实现远程定时通断控制

怎样在共享自习室灯光设备控制中集成智能设备以实现远程指令开关控制

怎么在共享茶室安全监控中集成智能硬件来实现远程烟雾浓度监测

怎样在自动贩卖机通断电控制中接入智能设备来实现远程参数配置管理

怎样在培训教室人体存在监测中集成智能硬件来实现远程人体存在状态监测