展会现场照明控制：怎样把智能触摸开关接入到软件项目中_解决方案

CATALOG

一、解决概述

展会现场照明控制的典型挑战包括：展位数量多、电源开关分散、不同展区需要独立照明、闭展后需逐一关灯。传统方式依赖人工逐个展位检查，效率低且容易遗漏。

本方案利用芯步智能触摸墙壁开关(1路/2路)的86型标准安装特性，将展会各展位的照明线路接入智能开关，通过HTTP接口与展会管理系统对接，实现：

远程集中控制：通过管理后台一键开关任意展位照明
多路独立控制(2路版本)：分别控制展位内的主照明和氛围灯光
场景联动：按展区批量开关、定时策略、日常展期自动控制
状态保持：关键展位可锁定照明状态，防止现场误触
私有化部署：数据可完全运行在局域网内，满足安全要求

二、核心技术能力分析

2.1 产品选型对比

对比项	1路智能触摸开关	2路智能触摸开关
产品型号	UNI-KG-CM-1	UNI-KG-CM-2
控制路数	1路独立输出	2路独立输出
适用场景	单路照明控制(小展位)	主照明+氛围灯独立控制(大展位)
安装方式	标准86型底盒安装	标准86型底盒安装
工作电压	100-250V AC	100-250V AC
单路负载	MAX 2200W(阻性)/LED<300W	MAX 2200W(阻性)/LED<300W
无线连接	WiFi 2.4GHz	WiFi 2.4GHz
控制协议	HTTP接口	HTTP接口
私有化部署	✅ 支持局域网控制	✅ 支持局域网控制

2.2 核心命令表

根据芯步接口规范，智能触摸开关支持以下核心命令

命令类型	1路版本JSON格式	2路版本JSON格式	功能说明
开启照明	`{"power1":"1"}`	`{"power1":"1"}`	开启线路1照明
关闭照明	`{"power1":"0"}`	`{"power1":"0"}`	关闭线路1照明
双路独立控制	不适用	`{"power1":"1","power2":"0"}`	主照明开，氛围灯关
状态保持(锁定)	`{"power1":{"keep":"1","revert":"3"}}`	`{"power1":{"keep":"1","revert":"3"}}`	强制锁定开状态，用户手动关灯3秒后自动恢复
先断后通(临时关闭)	`{"reset1":"3000"}`	`{"reset1":"3000"}`	关闭3秒后自动恢复
先通后断(临时开启)	`{"point1":"3000"}`	`{"point1":"3000"}`	开启3秒后自动关闭
全部开启	`{"batch":{"power":"1"}}`	`{"batch":{"power":"1"}}`	所有线路同时开启
全部关闭	`{"batch":{"power":"0"}}`	`{"batch":{"power":"0"}}`	所有线路同时关闭

2.3 API鉴权与请求格式

芯步API采用动态签名验证机制

请求地址:https://api.thingboot.com/{AppId}/device/control/?sign={sign}&ts={ts}
请求方法:POST
Content-Type:application/json

签名算法:
md5_secret = md5(AppSecret)
sign = md5(md5_secret + ts)

参数说明:
- AppId:应用ID，在控制台获取
- AppSecret:应用密钥，在控制台获取
- ts:当前Unix时间戳(秒)

请求Body示例(以2路开关开启第1路为例)：

⚠️ 重要说明：API返回code:200仅表示平台已接收指令，不代表设备执行成功。若设备离线，命令不会生效。通过消息推送机制确认执行结果。

三、展会照明控制集成方案

3.1 整体架构

┌─────────────────────────────────────────────────────────────────┐
│                        展会现场                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                    展位A                                 │   │
│  │  ┌─────────────────┐    ┌─────────────────┐            │   │
│  │  │ 智能触摸开关2路 │    │   照明设备      │            │   │
│  │  │  (86型墙壁安装) │───▶│  主照明+射灯    │            │   │
│  │  └─────────────────┘    └─────────────────┘            │   │
│  └─────────────────────────────────────────────────────────┘   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                    展位B                                 │   │
│  │  ┌─────────────────┐    ┌─────────────────┐            │   │
│  │  │ 智能触摸开关1路 │    │   照明设备      │            │   │
│  │  │  (86型墙壁安装) │───▶│    展位灯      │            │   │
│  │  └─────────────────┘    └─────────────────┘            │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  网络:2.4G WiFi                                                │
└─────────────────────────────────────────────────────────────────┘
                                       │
                                       │ HTTP API
                                       ▼
┌─────────────────────────────────────────────────────────────────┐
│                       展会管理系统                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                    照明控制模块                          │   │
│  │  - 单展位远程开关                                       │   │
│  │  - 按展区批量控制                                       │   │
│  │  - 定时开关策略                                         │   │
│  │  - 场景模式(开展/午休/闭展/应急)                        │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘
                                       │
                                       ▼
┌─────────────────────────────────────────────────────────────────┐
│                       前端展示                                   │
│  - 管理后台:照明控制面板、展区地图                             │
│  - 展商端小程序:自主控制本展位照明(可选)                       │
└─────────────────────────────────────────────────────────────────┘

3.2 硬件安装步骤

步骤1：展位开关安装

拆卸展位原有86型墙壁开关
安装芯步智能触摸墙壁开关(标准86型底盒，直接平行替换)
接线方式与普通开关一致(火线L、零线N、灯控线L1/L2)
2路版本可分别接入主照明和氛围灯光

步骤2：网络配置

确保展位区域WiFi信号覆盖(设备仅支持2.4G频段)
通过芯步控制台为每个开关配网
设备可设定5组WiFi网络，自动连接信号最强的

步骤3：获取凭证

登录
在「开发设置」中获取 AppId 和 AppSecret
记录每个开关对应的设备ID，建立展位-设备映射表

3.3 代码集成示例

以下提供Python和Java两种语言的完整对接示例。

Python实现(推荐用于后端服务)

import hashlib
import time
import requests
import json
from typing import List, Dict, Optional
from flask import Flask, request, jsonify

app = Flask(__name__)

class ExhibitionLightController:
    """展会照明控制器类"""
    
    def __init__(self, app_id: str, app_secret: str):
        self.app_id = app_id
        self.app_secret = app_secret
        self.api_base = "https://api.thingboot.com"
    
    def _generate_sign(self, ts: int) -> str:
        """生成API签名:sign = md5(md5(AppSecret) + ts)"""
        md5_secret = hashlib.md5(self.app_secret.encode()).hexdigest()
        sign_str = md5_secret + str(ts)
        return hashlib.md5(sign_str.encode()).hexdigest()
    
    def _send_command(self, device_id: str, order: Dict) -> Optional[Dict]:
        """发送控制命令"""
        ts = int(time.time())
        sign = self._generate_sign(ts)
        url = f"{self.api_base}/{self.app_id}/device/control/?sign={sign}&ts={ts}"
        
        payload = {"device": device_id, "order": order}
        try:
            response = requests.post(url, json=payload, timeout=5)
            return response.json()
        except Exception as e:
            print(f"命令发送失败: {e}")
            return None
    
    # ========== 单展位控制 ==========
    def light_on(self, device_id: str, channel: int = 1) -> Optional[Dict]:
        """开启指定展位照明(channel=1或2)"""
        if channel == 1:
            return self._send_command(device_id, {"power1": "1"})
        else:
            return self._send_command(device_id, {"power2": "1"})
    
    def light_off(self, device_id: str, channel: int = 1) -> Optional[Dict]:
        """关闭指定展位照明"""
        if channel == 1:
            return self._send_command(device_id, {"power1": "0"})
        else:
            return self._send_command(device_id, {"power2": "0"})
    
    def dual_light_control(self, device_id: str, main: int, ambient: int) -> Optional[Dict]:
        """双路独立控制(2路版本):分别控制主照明和氛围灯光"""
        return self._send_command(device_id, {
            "power1": str(main),
            "power2": str(ambient)
        })
    
    # ========== 批量控制 ==========
    def batch_on(self, device_ids: List[str], channel: int = 1) -> List[Dict]:
        """批量开启多个展位照明"""
        results = []
        for device_id in device_ids:
            result = self.light_on(device_id, channel)
            results.append(result)
            time.sleep(0.1)  # 避免请求过快
        return results
    
    def batch_off(self, device_ids: List[str], channel: int = 1) -> List[Dict]:
        """批量关闭多个展位照明"""
        results = []
        for device_id in device_ids:
            result = self.light_off(device_id, channel)
            results.append(result)
            time.sleep(0.1)
        return results
    
    def all_on(self, all_device_ids: List[str]) -> List[Dict]:
        """开展时一键开启所有展位照明"""
        print(f"正在开启所有展位照明，共{len(all_device_ids)}个展位")
        return self.batch_on(all_device_ids)
    
    def all_off(self, all_device_ids: List[str]) -> List[Dict]:
        """闭展时一键关闭所有展位照明"""
        print(f"正在关闭所有展位照明，共{len(all_device_ids)}个展位")
        return self.batch_off(all_device_ids)
    
    # ========== 高级功能 ==========
    def force_keep_on(self, device_id: str, channel: int = 1, revert_seconds: int = 5) -> Optional[Dict]:
        """
        状态保持:强制保持照明开启，防止现场误操作
        用户手动关闭后，revert_seconds秒后会自动恢复开启[citation:4]
        """
        return self._send_command(device_id, {
            f"power{channel}": {"keep": "1", "revert": str(revert_seconds)}
        })
    
    def temp_off(self, device_id: str, channel: int = 1, duration_ms: int = 30000) -> Optional[Dict]:
        """
        临时关闭:关闭后自动恢复(适用于午休时段短暂关灯)
        duration_ms: 关闭持续时间(毫秒)，如30000为30秒
        """
        return self._send_command(device_id, {f"reset{channel}": str(duration_ms)})
    
    def temp_on(self, device_id: str, channel: int = 1, duration_ms: int = 30000) -> Optional[Dict]:
        """
        临时开启:开启后自动关闭(适用于临时照明需求)[citation:4]
        duration_ms: 开启持续时间(毫秒)
        """
        return self._send_command(device_id, {f"point{channel}": str(duration_ms)})

# ========== 展会配置 ==========
# 展位与设备ID映射表(1路开关)
BOOTH_DEVICES_1CH = {
    "A01": "820720",
    "A02": "820721",
    "B01": "820722",
}
# 展位与设备ID映射表(2路开关)- 支持主照明+氛围灯
BOOTH_DEVICES_2CH = {
    "C01": {"device_id": "820723", "main_channel": 1, "ambient_channel": 2},
    "C02": {"device_id": "820724", "main_channel": 1, "ambient_channel": 2},
}

# API凭证
APP_ID = "YOUR_APP_ID"
APP_SECRET = "YOUR_APP_SECRET"

controller = ExhibitionLightController(APP_ID, APP_SECRET)

# ========== Flask API接口 ==========

@app.route('/api/light/on', methods=['POST'])
def light_on():
    """单展位开灯"""
    data = request.get_json()
    booth_id = data.get('booth_id')
    channel = data.get('channel', 1)
    
    device_id = BOOTH_DEVICES_1CH.get(booth_id)
    if not device_id:
        return jsonify({"code": 404, "message": f"展位{booth_id}未配置"})
    
    result = controller.light_on(device_id, channel)
    return jsonify({"code": 200 if result else 500, "message": f"展位{booth_id}照明已开启"})

@app.route('/api/light/off', methods=['POST'])
def light_off():
    """单展位关灯"""
    data = request.get_json()
    booth_id = data.get('booth_id')
    
    device_id = BOOTH_DEVICES_1CH.get(booth_id)
    if not device_id:
        return jsonify({"code": 404, "message": f"展位{booth_id}未配置"})
    
    result = controller.light_off(device_id)
    return jsonify({"code": 200 if result else 500, "message": f"展位{booth_id}照明已关闭"})

@app.route('/api/light/dual-control', methods=['POST'])
def dual_light_control():
    """双路独立控制(2路开关，主照明+氛围灯)"""
    data = request.get_json()
    booth_id = data.get('booth_id')
    main_status = data.get('main', 1)      # 1=开，0=关
    ambient_status = data.get('ambient', 0) # 1=开，0=关
    
    booth_config = BOOTH_DEVICES_2CH.get(booth_id)
    if not booth_config:
        return jsonify({"code": 404, "message": f"展位{booth_id}未配置2路开关"})
    
    result = controller.dual_light_control(
        booth_config['device_id'],
        main_status,
        ambient_status
    )
    return jsonify({"code": 200 if result else 500, "message": f"展位{booth_id}照明已设置"})

@app.route('/api/exhibition/all-on', methods=['POST'])
def all_lights_on():
    """开展:一键开启所有展位照明"""
    all_device_ids = list(BOOTH_DEVICES_1CH.values())
    results = controller.all_on(all_device_ids)
    success_count = sum(1 for r in results if r and r.get('code') == 200)
    return jsonify({
        "code": 200,
        "message": f"已开启{success_count}/{len(all_device_ids)}个展位照明"
    })

@app.route('/api/exhibition/all-off', methods=['POST'])
def all_lights_off():
    """闭展:一键关闭所有展位照明"""
    all_device_ids = list(BOOTH_DEVICES_1CH.values())
    results = controller.all_off(all_device_ids)
    success_count = sum(1 for r in results if r and r.get('code') == 200)
    return jsonify({
        "code": 200,
        "message": f"已关闭{success_count}/{len(all_device_ids)}个展位照明"
    })

@app.route('/api/area/off', methods=['POST'])
def area_lights_off():
    """按展区批量关灯"""
    data = request.get_json()
    area = data.get('area')  # 'A区', 'B区'等
    
    # 根据区域获取设备ID列表(示例)
    area_devices = {
        "A区": ["820720", "820721"],
        "B区": ["820722", "820723"],
    }.get(area, [])
    
    results = controller.batch_off(area_devices)
    success_count = sum(1 for r in results if r and r.get('code') == 200)
    return jsonify({"code": 200, "message": f"{area}已关闭{success_count}个展位"})

@app.route('/api/light/force-keep', methods=['POST'])
def force_keep_on():
    """状态保持:锁定展位照明，防止现场误关闭"""
    data = request.get_json()
    booth_id = data.get('booth_id')
    
    device_id = BOOTH_DEVICES_1CH.get(booth_id)
    if not device_id:
        return jsonify({"code": 404, "message": f"展位{booth_id}未配置"})
    
    # 强制保持开启，用户手动关灯5秒后自动恢复
    result = controller.force_keep_on(device_id, channel=1, revert_seconds=5)
    return jsonify({"code": 200 if result else 500, "message": f"展位{booth_id}照明已锁定"})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Java实现

import okhttp3.*;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class ExhibitionLightController {
    private final String appId;
    private final String appSecret;
    private final OkHttpClient client;
    private static final String API_BASE = "https://api.thingboot.com";
    
    public ExhibitionLightController(String appId, String appSecret) {
        this.appId = appId;
        this.appSecret = appSecret;
        this.client = new OkHttpClient();
    }
    
    private 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 (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }
    
    private String sendCommand(String deviceId, String orderJson) throws IOException {
        long ts = System.currentTimeMillis() / 1000;
        String md5Secret = md5(appSecret);
        String sign = md5(md5Secret + ts);
        String url = API_BASE + "/" + appId + "/device/control/?sign=" + sign + "&ts=" + ts;
        
        String bodyJson = "{\"device\":\"" + deviceId + "\",\"order\":" + orderJson + "}";
        RequestBody body = RequestBody.create(bodyJson, MediaType.parse("application/json"));
        
        Request request = new Request.Builder()
                .url(url)
                .post(body)
                .build();
        
        try (Response response = client.newCall(request).execute()) {
            return response.body() != null ? response.body().string() : null;
        }
    }
    
    // 开启照明(1路开关)
    public void lightOn(String deviceId) throws IOException {
        sendCommand(deviceId, "{\"power1\":\"1\"}");
    }
    
    // 关闭照明(1路开关)
    public void lightOff(String deviceId) throws IOException {
        sendCommand(deviceId, "{\"power1\":\"0\"}");
    }
    
    // 双路独立控制(2路开关)
    public void dualControl(String deviceId, int mainStatus, int ambientStatus) throws IOException {
        sendCommand(deviceId, "{\"power1\":\"" + mainStatus + "\",\"power2\":\"" + ambientStatus + "\"}");
    }
    
    // 批量关闭
    public void batchOff(String[] deviceIds) throws IOException {
        for (String deviceId : deviceIds) {
            lightOff(deviceId);
            Thread.sleep(100);
        }
    }
}

四、展会典型应用场景

4.1 每日展期自动控制

场景：展会期间，系统根据时间自动开关展位照明，无需人工干预。

4.2 展台主照明+氛围灯独立控制

场景：使用2路开关分别控制展台的主照明和氛围灯光，营造不同展示效果。

4.3 按展区批量控制

场景：展会结束后，按展区依次关闭照明，便于分区域管理。

4.4 关键展位状态保持

场景：重要展位的照明需要保持开启状态，防止现场误触关闭。

4.5 私有化部署(局域网控制)

对于内网环境，芯步设备支持私有化部署，可直接向设备IP下发命令

五、集成步骤

步骤一：硬件采购与安装

根据展位需求采购1路或2路智能触摸开关
由电工在对应展位更换开关(86型底盒直接替换)
接入展位照明设备

步骤二：平台配置

登录
在「开发设置」中获取 AppId 和 AppSecret
为每个开关配网，记录设备ID，建立展位-设备映射表

步骤三：后端集成

将上述ExhibitionLightController类集成到展会管理系统中
实现单展位控制、批量控制、定时任务等接口
配置展区设备映射关系

步骤四：前端接入

在管理后台接入照明控制面板
提供展位地图可视化控制
可选：为展商端小程序提供本展位自主照明控制

六、总结

优势	说明
零改造安装	标准86型底盒直接替换原有开关，无需重新布线
远程集中控制	支持单展位、展区、全场批量控制，闭展一键关灯
双路独立控制	2路版本可分别控制展台主照明和氛围灯光
HTTP开放接口	任何编程语言均可对接，10分钟完成基础集成
状态保持	可锁定关键展位照明状态，防止现场误操作
私有化部署	支持纯局域网运行，数据不出展会场馆
多网络备份	支持设定5组WiFi，自动连接信号最强的

七、注意事项

负载限制 ⚠️：LED、节能灯等感性负载需控制在300W以内，单路阻性负载不超过2200W
WiFi信号：确保展位区域WiFi信号良好(设备仅支持2.4G频段)
API响应说明：返回code:200仅表示平台接收指令，不代表设备执行成功
专业安装：涉及强电操作，必须由持证电工按照安全规范安装
设备映射：在数据库中维护展位号与设备ID的映射关系，便于管理

通过以上方案，你可以快速将芯步智能触摸墙壁开关集成到展会照明管理系统中，实现远程集中控制、展区分区管理、定时自动开关等核心功能，提升展会照明管理效率。如有疑问，可访问获取详细产品手册和技术支持。