共享自习室前台语音引导场景：怎样把10W 智能云播报喇叭对接到自己的项目中_解决方案

CATALOG

[69189] 文档版本：V1.0 更新日期：2026年5月 适用对象：软件工程师、智慧空间集成商、共享自习室运营方

第一章：共享自习室前台场景痛点与解决概述

1.1 共享自习室前台服务的运营挑战

在共享自习室、无人值守自习空间等场景中，前台语音引导是实现自助化服务和提升用户体验的关键环节。传统服务模式面临以下痛点：

痛点	具体表现	带来的影响
入座流程指引缺失	用户到店后不清楚如何开台选座	需人工引导，无法实现完全自助
秩序管理依赖人工	大声喧哗、违规用餐需人工提醒	运营成本高，响应滞后
重要通知触达难	优惠活动、临时闭馆等信息无法有效传达	用户错过重要信息
服务缺乏标准化	不同工作人员告知内容不一致	用户体验参差不齐

1.2 解决方案：10W智能云播报喇叭实现全自动引导

芯步10W智能云播报喇叭通过标准HTTP接口与自习室管理软件对接，实现“用户扫码入座-自动语音引导-广播通知触达”的自动化服务闭环。

核心价值

芯片级TTS：文本语音合成在设备端完成，声音自然柔和，毫秒级响应
开放HTTP接口：适用于任何支持HTTP请求的编程语言，无缝对接微信小程序、管理后台
即插即用：2p插头设计，无需安装布线
多场景适配：支持入座引导、超时提醒、开台欢迎、广播通知等多种场景
私有化部署：支持纯局域网运行，数据不出自习室

1.3 10W智能云播报喇叭核心参数

本方案推荐选用智能语音喇叭3或智能语音喇叭Mini作为前台语音引导设备：

参数项	规格详情
产品型号	智能语音喇叭3 / 智能语音喇叭Mini
输出功率	10W
发声单元	双发声单元，音量大
安装方式	2p插头，即插即用，无需安装
外壳材质	防火V0级PC，耐高温，符合安规标准
产品尺寸	80mm × 80mm × 50mm（喇叭3）/ 65mm × 65mm × 38.4mm（Mini）
产品净重	105g（喇叭3）
工作电压	100-250V AC（交流/市电）
待机功耗	0.4W（静音）- 3.7W（最大音量播放）
无线连接	WiFi IEEE 802.11 b/g/n 2.4GHz
音色支持	纯中文版支持男声/女声切换
接口类型	开放HTTP API，支持所有编程语言
私有部署	支持自建消息服务器，可运行于纯局域网

1.4 版本选择

版本	特点	推荐场景
智能语音喇叭3	双发声单元、环状LED灯带、即插即用	前台桌面、服务台（推荐）
智能语音喇叭Mini	超小型、即插即用	空间有限的桌面
智能语音台卡	站立式设计，带底座	前台接待台
智能语音喇叭86型	86型底盒安装，嵌入墙体	装修阶段预埋

第二章：HTTP接口协议详解

2.1 整体集成架构

芯步智能云播报喇叭采用标准的HTTP请求-响应模型，适用于任何支持HTTP请求的编程语言，可无缝接入自习室管理微信小程序、管理后台等系统

graph LR
    subgraph 用户端
        A[用户小程序/扫码]
    end
    
    subgraph 软件层
        B[自习室管理平台]
    end
    
    subgraph 网络层
        C[芯步API网关
api.thingboot.com]
    end
    
    subgraph 硬件层
        D[10W智能云播报喇叭]
    end
    
    A -->|扫码入座| B
    B -->|HTTP POST| C
    C -->|MQTT透传| D
    D -->|TTS合成| 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]

核心代码实现

安全要点

两次MD5输出均为32位小写十六进制字符串
ts需与服务端时间同步，误差不超过5分钟
AppSecret需妥善保管，切勿硬编码在前端代码中

2.4 核心命令：文本播报

命令格式

参数说明

play:gbk：固定前缀，表示文本播报（GBK编码）
16：音量，范围0-16，数字越大音量越大
文本内容：支持中文、英文、数字、标点符号

完整请求示例

2.5 支持的控制命令

芯步智能云播报喇叭支持丰富的控制命令

命令类别	命令示例	说明
文本播报	`{"play:gbk:16":"文本"}`	核心功能，TTS实时合成播报
停止播报	`{"stop":"1"}`	停止当前播报
音量设置	`{"volume":"9"}`	0-9级
音色设置	`{"voice":"1"}`	0-女声，1-男声
语速设置	`{"speed":"5"}`	0-9级，5为正常
语调设置	`{"tone":"5"}`	0-9级
铃声	`{"ring":"3"}`	1-5，内置5种铃声
提示音	`{"message":"3"}`	1-5，内置5种提示音
警示音	`{"alert":"3"}`	1-5，内置5种警示音

数字读法支持：TTS引擎智能识别数字读法，支持常规数字、金额、手机号等格式。多音字内置上下文识别能力。

第三章：多语言代码实现

3.1 Python完整实现

# -*- coding: utf-8 -*-
import hashlib
import time
import requests
import json
from typing import Dict, Optional
from datetime import datetime
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 calculate_sign(app_secret: str, ts: int) -> str:
    """计算芯步API签名:md5(md5(secret) + ts)"""
    first_md5 = calculate_md5(app_secret)
    sign_raw = first_md5 + str(ts)
    sign = calculate_md5(sign_raw)
    return sign

def send_command(order: dict, device_id: str = None) -> dict:
    """向设备发送命令"""
    ts = int(time.time())
    sign = calculate_sign(APP_SECRET, ts)
    
    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 speak(text: str, volume: int = 14, wait: bool = False) -> dict:
    """
    文本语音播报（核心功能）
    
    参数:
        text: 播报文本内容
        volume: 音量 0-16，默认14
        wait: 是否等待播报完成
    """
    if len(text) > 200:
        print(f"[警告] 文本长度{len(text)}超过200字符，拆分播报")
    
    play_cmd = f"play:gbk:{volume}"
    result = send_command({play_cmd: text})
    
    # 可选的等待机制（实际应用中较少需要等待）
    if wait:
        time.sleep(len(text) / 10)  # 粗略估算播报时长
    return result

def stop_speak() -> dict:
    """停止当前播报"""
    return send_command({"stop": "1"})

def set_volume(volume: int) -> dict:
    """设置设备音量（0-9）"""
    return send_command({"volume": str(volume)})

def set_voice(voice_type: int) -> dict:
    """设置音色:0-女声，1-男声"""
    return send_command({"voice": str(voice_type)})

def set_speed(speed: int) -> dict:
    """设置语速:0-9，5为正常"""
    return send_command({"speed": str(speed)})

def play_ring(ring_type: int = 3) -> dict:
    """播放内置铃声（1-5）"""
    return send_command({"ring": str(ring_type)})

def play_alert(alert_type: int = 3) -> dict:
    """播放内置警示音（1-5）"""
    return send_command({"alert": str(alert_type)})

def play_message_tone(tone_type: int = 3) -> dict:
    """播放内置提示音（1-5）"""
    return send_command({"message": str(tone_type)})

# ========== 自习室业务场景类 ==========

class StudyRoomSpeaker:
    """自习室前台语音引导控制器"""
    
    def __init__(self, device_id: str, room_name: str = "自习室"):
        """
        初始化
        
        参数:
            device_id: 喇叭设备ID
            room_name: 自习室名称
        """
        self.device_id = device_id
        self.room_name = room_name
        self.active_sessions = {}  # 活跃会话缓存
    
    # ========== 欢迎与入座引导 ==========
    def welcome_new_user(self, user_name: str = None):
        """
        新用户欢迎引导
        """
        if user_name:
            text = f"欢迎{user_name}同学来到{self.room_name}，请扫码选择座位，安静学习"
        else:
            text = f"欢迎来到{self.room_name}，请扫码开台入座，祝您学习愉快"
        
        # 先播放提示音
        play_message_tone(3)
        time.sleep(0.3)
        speak(text, volume=14)
    
    def seat_guide(self, seat_number: str):
        """
        入座引导
        
        参数:
            seat_number: 座位号
        """
        text = f"您已成功开台，座位号{seat_number}。请对号入座，保持安静"
        speak(text, volume=14)
    
    def checkin_reminder(self):
        """入场后引导提示"""
        text = "自习期间请保持手机静音，如需用餐请到休息区"
        speak(text, volume=12)
    
    # ========== 超时与延时提醒 ==========
    def timeout_warning(self, seat_number: str, extra_minutes: int = 10):
        """
        超时提醒
        
        参数:
            seat_number: 座位号
            extra_minutes: 额外使用时间（分钟）
        """
        # 播报警示音引起注意
        play_alert(3)
        time.sleep(0.3)
        text = f"{seat_number}号座位，您的使用时间即将结束，如需继续使用请续费，{extra_minutes}分钟后将自动断电"
        speak(text, volume=15)
    
    def session_expired(self, seat_number: str):
        """
        会话结束提醒
        """
        text = f"{seat_number}号座位使用时间已到，感谢您的使用，欢迎下次光临"
        speak(text, volume=14)
    
    def extend_success(self, seat_number: str, extra_minutes: int):
        """
        续费成功提醒
        """
        text = f"{seat_number}号座位已成功续费{extra_minutes}分钟，祝您学习愉快"
        speak(text, volume=14)
    
    # ========== 广播通知 ==========
    def broadcast_notice(self, message: str, is_urgent: bool = False):
        """
        广播通知
        
        参数:
            message: 通知内容
            is_urgent: 是否紧急（会播放警示音）
        """
        if is_urgent:
            for _ in range(2):
                play_alert(5)
                time.sleep(0.3)
        
        speak(message, volume=16 if is_urgent else 14)
    
    def closing_reminder(self, minutes_left: int = 30):
        """
        闭馆提醒
        """
        if minutes_left <= 10:
            text = f"各位同学请注意，自习室将在{minutes_left}分钟后关闭，请收拾好个人物品，准备离开现场时"
            volume = 16
        else:
            text = f"温馨提示，自习室将在{minutes_left}分钟后关闭，请合理安排学习时间"
            volume = 14
        
        # 先播报铃声引起注意
        play_ring(3)
        time.sleep(0.3)
        speak(text, volume)
    
    # ========== 活动与促销播报 ==========
    def promotion_broadcast(self, content: str):
        """
        活动/促销播报
        """
        text = f"活动通知:{content}"
        speak(text, volume=13)
    
    def member_benefit(self, user_name: str, benefit: str):
        """
        会员权益播报
        """
        text = f"尊敬的{user_name}会员，{benefit}"
        speak(text, volume=12)
    
    # ========== 秩序提醒 ==========
    def noise_warning(self, seat_area: str = None):
        """
        噪音提醒
        """
        if seat_area:
            text = f"{seat_area}区域的同学请注意，请保持安静，共同维护学习环境"
        else:
            text = "亲爱的同学们，请保持安静，手机请调至静音模式，感谢配合"
        
        play_alert(3)
        time.sleep(0.3)
        speak(text, volume=14)
    
    def food_restriction(self):
        """用餐限制提醒"""
        text = "温馨提示，自习室内请勿用餐，如有需要请到指定休息区"
        speak(text, volume=12)

# ========== 自习室预定系统集成 ==========
class StudyRoomIntegration:
    """自习室管理平台与语音系统集成"""
    
    def __init__(self, speaker: StudyRoomSpeaker):
        self.speaker = speaker
        self.order_timers = {}  # 订单定时器
    
    def on_user_checkin(self, user_info: dict, seat_number: str):
        """
        用户开台事件处理
        
        参数:
            user_info: 用户信息
            seat_number: 座位号
        """
        # 1. 欢迎语
        self.speaker.welcome_new_user(user_info.get("name"))
        
        # 2. 入座引导
        time.sleep(1)
        self.speaker.seat_guide(seat_number)
        
        # 3. 入场后提示
        time.sleep(0.5)
        self.speaker.checkin_reminder()
        
        # 4. 设置超时提醒定时器
        self._schedule_timeout_warning(seat_number, user_info.get("duration", 180))
    
    def on_user_extend(self, seat_number: str, extra_minutes: int):
        """
        用户续费事件处理
        """
        self.speaker.extend_success(seat_number, extra_minutes)
        # 重置定时器
        self._reschedule_timeout(seat_number, extra_minutes)
    
    def on_session_end(self, seat_number: str):
        """
        会话结束事件处理
        """
        self.speaker.session_expired(seat_number)
    
    def _schedule_timeout_warning(self, seat_number: str, total_minutes: int):
        """安排超时提醒"""
        warn_time = (total_minutes - 10) * 60  # 结束前10分钟提醒
        if warn_time > 0:
            timer = threading.Timer(warn_time, 
                                   lambda: self.speaker.timeout_warning(seat_number, 10))
            self.order_timers[f"{seat_number}_warn"] = timer
            timer.start()
    
    def _reschedule_timeout(self, seat_number: str, extra_minutes: int):
        """续费后重新安排提醒"""
        # 取消原有提醒
        if f"{seat_number}_warn" in self.order_timers:
            self.order_timers[f"{seat_number}_warn"].cancel()
        # 设置新提醒
        self._schedule_timeout_warning(seat_number, extra_minutes)

# ========== 定时广播任务 ==========
class ScheduledBroadcast:
    """定时广播管理"""
    
    def __init__(self, speaker: StudyRoomSpeaker):
        self.speaker = speaker
    
    def setup_daily_schedule(self):
        """设置每日定时广播"""
        import schedule
        
        # 开馆时间提醒（8:50）
        schedule.every().day.at("08:50").do(
            lambda: self.speaker.broadcast_notice(
                "自习室即将开放，请扫码入座，祝您学习愉快"
            )
        )
        
        # 午间休息提醒（12:00）
        schedule.every().day.at("12:00").do(
            lambda: self.speaker.broadcast_notice(
                "午间休息时间，需要用餐的同学请到休息区"
            )
        )
        
        # 闭馆前30分钟提醒（21:30）
        schedule.every().day.at("21:30").do(
            lambda: self.speaker.closing_reminder(30)
        )
        
        # 闭馆前10分钟提醒（21:50）
        schedule.every().day.at("21:50").do(
            lambda: self.speaker.closing_reminder(10)
        )
        
        # 闭馆提醒（22:00）
        schedule.every().day.at("22:00").do(
            lambda: self.speaker.broadcast_notice(
                "自习室已关闭，感谢您的使用，晚安"
            )
        )

# ========== API服务接口（Flask示例） ==========
from flask import Flask, request, jsonify

app = Flask(__name__)
speaker = None  # 全局喇叭实例

@app.route('/api/speak', methods=['POST'])
def api_speak():
    """通用语音播报接口"""
    data = request.json
    text = data.get('text')
    volume = data.get('volume', 14)
    
    if not text:
        return jsonify({"success": False, "error": "text required"}), 400
    
    result = speak(text, volume)
    return jsonify({"success": not result.get("error"), "result": result})

@app.route('/api/welcome', methods=['POST'])
def api_welcome():
    """欢迎用户接口"""
    data = request.json
    user_name = data.get('user_name')
    speaker.welcome_new_user(user_name)
    return jsonify({"success": True})

@app.route('/api/broadcast', methods=['POST'])
def api_broadcast():
    """广播通知接口"""
    data = request.json
    message = data.get('message')
    is_urgent = data.get('is_urgent', False)
    speaker.broadcast_notice(message, is_urgent)
    return jsonify({"success": True})

# ========== 调用示例 ==========
if __name__ == "__main__":
    # 初始化喇叭控制器
    speaker = StudyRoomSpeaker(DEVICE_ID, "静心自习室")
    
    # 示例1:新用户欢迎
    # speaker.welcome_new_user("张三")
    
    # 示例2:入座引导
    # speaker.seat_guide("A01")
    
    # 示例3:超时提醒
    # speaker.timeout_warning("A01", 10)
    
    # 示例4:广播通知
    # speaker.broadcast_notice("明天自习室开放时间调整为9:00-22:00", is_urgent=False)
    
    # 示例5:闭馆提醒
    # speaker.closing_reminder(30)
    
    # 启动API服务
    # app.run(host='0.0.0.0', port=5000)

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'
};

// 生成签名:md5(md5(secret) + ts)
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 speak(text, volume = 14) {
    if (text.length > 200) {
        console.warn(`文本长度${text.length}超过200字符`);
    }
    return sendCommand({ [`play:gbk:${volume}`]: text });
}

// 停止播报
async function stopSpeak() {
    return sendCommand({ stop: "1" });
}

// 设置音量
async function setVolume(volume) {
    return sendCommand({ volume: String(volume) });
}

// 自习室喇叭控制器类
class StudyRoomSpeaker {
    constructor(deviceId, roomName = '自习室') {
        this.deviceId = deviceId;
        this.roomName = roomName;
    }
    
    async welcomeNewUser(userName = null) {
        const text = userName 
            ? `欢迎${userName}同学来到${this.roomName}，请扫码选择座位，安静学习`
            : `欢迎来到${this.roomName}，请扫码开台入座，祝您学习愉快`;
        await sendCommand({ message: "3" });  // 播放提示音
        await new Promise(resolve => setTimeout(resolve, 300));
        return speak(text, 14);
    }
    
    async seatGuide(seatNumber) {
        const text = `您已成功开台，座位号${seatNumber}。请对号入座，保持安静`;
        return speak(text, 14);
    }
    
    async timeoutWarning(seatNumber, extraMinutes = 10) {
        await sendCommand({ alert: "3" });
        await new Promise(resolve => setTimeout(resolve, 300));
        const text = `${seatNumber}号座位，您的使用时间即将结束，如需继续使用请续费，${extraMinutes}分钟后将自动断电`;
        return speak(text, 15);
    }
    
    async broadcastNotice(message, isUrgent = false) {
        if (isUrgent) {
            for (let i = 0; i < 2; i++) {
                await sendCommand({ alert: "5" });
                await new Promise(resolve => setTimeout(resolve, 300));
            }
        }
        return speak(message, isUrgent ? 16 : 14);
    }
    
    async closingReminder(minutesLeft = 30) {
        await sendCommand({ ring: "3" });
        await new Promise(resolve => setTimeout(resolve, 300));
        
        let text;
        if (minutesLeft <= 10) {
            text = `各位同学请注意，自习室将在${minutesLeft}分钟后关闭，请收拾好个人物品，准备离开现场时`;
        } else {
            text = `温馨提示，自习室将在${minutesLeft}分钟后关闭，请合理安排学习时间`;
        }
        return speak(text, minutesLeft <= 10 ? 16 : 14);
    }
    
    async noiseWarning(seatArea = null) {
        const text = seatArea 
            ? `${seatArea}区域的同学请注意，请保持安静，共同维护学习环境`
            : `亲爱的同学们，请保持安静，手机请调至静音模式，感谢配合`;
        await sendCommand({ alert: "3" });
        await new Promise(resolve => setTimeout(resolve, 300));
        return speak(text, 14);
    }
}

// 使用示例
// const speaker = new StudyRoomSpeaker(config.deviceId, '静心自习室');
// speaker.welcomeNewUser('张三');
// speaker.seatGuide('A01');
// speaker.broadcastNotice('明天自习室开放时间调整为9:00-22:00');

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 StudyRoomSpeaker {
    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 speak(String text, int volume) 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\":{\"play:gbk:%d\":\"%s\"}}",
            DEVICE_ID, volume, text
        );
        
        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 welcome(String userName) throws Exception {
        String text = userName != null 
            ? "欢迎" + userName + "同学来到自习室，请扫码选择座位，安静学习"
            : "欢迎来到自习室，请扫码开台入座，祝您学习愉快";
        speak(text, 14);
    }
    
    public static void main(String[] args) throws Exception {
        welcome("张三");
    }
}

3.4 Shell脚本（cURL）实现

第四章：共享自习室业务场景集成

4.1 系统集成架构

自习室语音引导系统可与预订平台、门禁系统深度集成：

graph TB
    subgraph 用户端
        A[用户小程序/扫码]
        B[入座/离座]
    end
    
    subgraph 平台层
        C[自习室管理平台]
        C1[座位管理]
        C2[订单管理]
        C3[计时计费]
        C4[语音播报]
    end
    
    subgraph 设备层
        D[芯步API网关]
        E[10W云播报喇叭]
        F[智能电源控制器]
    end
    
    subgraph 感知层
        G[人体传感器]
    end
    
    A -->|开台选座| C1
    C1 --> C2
    C2 --> C3
    C2 --> C4
    C4 --> D
    D --> E
    F -->|通电| H[座位电源]
    G -->|无人检测| C3

4.2 第一种场景：新用户入座全自动引导

业务需求：用户首次到店扫码开后，系统自动播放入座指引和自习室规则。

实现流程

用户扫码选择座位并支付
系统完成开台，记录订单
自动触发语音播报：欢迎语 → 入座引导 → 规则提醒

代码实现

4.3 第二种场景：使用时长超时提醒

业务需求：用户使用时间即将结束时，提前播报提醒。

实现流程

系统记录用户开始时间
结束前10分钟触发提醒
结束时播报感谢语

代码实现