广告灯箱电路控制：怎样将40A带计量数显额定 8800W 断路器接入到自己的项目中_解决方案

CATALOG

[92921] 文档版本：V1.0 更新日期：2026年5月 适用对象：软件工程师、物联网集成商、户外广告运营方

第一章：场景痛点与解决概述

1.1 广告灯箱电路控制的业务挑战

在城市户外广告、商圈灯箱、公交站牌广告等场景中，广告灯箱的电路控制涉及远程开关、用电监测、故障告警等多个维度。传统管理方式面临以下痛点：

痛点	具体表现	带来的影响
能耗无法统计	灯箱实际用电量无数据支撑	无法核算运营成本，难以优化投放策略
故障发现滞后	灯箱损坏需人工巡检	存在广告费损失风险
远程控制缺失	需现场操作开关	无法实现集中管理和时段自动控制
改造成本高	加装独立电表需额外设备	增加硬件投入和安装复杂度

1.2 解决方案：计量数显断路器实现智能灯箱控制

芯步智能大功率断路器[计量数显版]40A集成了远程控制和电能计量两大核心功能，通过HTTP接口与广告管理平台对接，实现“远程通断、实时计量、异常告警、数据分析”的完整灯箱管理闭环。

核心价值

一体化设计：通断控制 + 电能计量二合一，无需额外电表
实时数据：随时查询当前功率、累计用电量
远程可控：通过HTTP接口实现集中管理
开放协议：适用于任何支持HTTP请求的编程语言

与其他方案对比

传统微型断路器（如DZ47S）仅支持手动分断，无远程控制和计量功能
普通智能开关通常不具备计量和40A大功率能力
本方案集远程控制、功率计量、大功率承载于一体

1.3 智能大功率断路器[计量数显版]40A核心参数

本方案产品详细参数如下

参数项	规格详情
产品型号	UNI-DLQ-M-40A-PD
额定电流	MAX 40A
阻性负载功率	MAX 8000W（白炽灯、电热器等）
感性负载功率	MAX 1400W（LED灯、电子镇流器等）
工作电压	AC 85-265V
安装方式	35mm DIN导轨式
联网方式	WiFi 2.4GHz / 4G可选
待机功耗	0.8W
外壳材质	防火V0级PC，耐高温，符合安规标准

1.4 广告灯箱负载功率说明

广告灯箱负载类型直接影响功率限制

负载类型	功率限制	典型设备
阻性负载	MAX 8000W	传统钨丝灯、电热元件
感性负载	MAX 1400W	LED灯、电子镇流器、节能灯

⚠️ 重要提示：广告灯箱普遍采用LED灯作为光源，属于感性负载，总功率需控制在1400W以内。如需更高功率，升级至50A或60A版本。

1.5 版本选型

版本	额定电流	阻性负载	感性负载	适用场景
40A版	MAX 40A	8000W	1400W	LED灯箱（推荐）
50A版	MAX 50A	10000W	1700W	大功率灯箱
60A版	MAX 60A	12000W	2000W	超大面积灯箱
4G版	同上	同上	同上	无WiFi覆盖场景

第二章：HTTP接口协议详解

2.1 整体架构

芯步智能断路器采用标准的HTTP请求-响应模型，适用于任何支持HTTP请求的编程语言

graph LR
    subgraph 软件层
        A[广告管理平台/小程序]
    end
    
    subgraph 网络层
        B[芯步API网关
api.thingboot.com]
    end
    
    subgraph 硬件层
        C[40A计量断路器
配电箱内]
    end
    
    A -- "HTTP POST (带签名)" --> B
    B -- "MQTT透传" --> C
    C -- "计量数据返回" --> A

性能指标：从命令下发到设备响应，端到端延迟约为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示例

2.4 核心命令集

同产品类型的设备命令格式统一，智能大功率断路器支持以下核心命令：

命令类别	命令示例	说明
接通电源	`{"power":"1"}`	闭合断路器，灯箱通电
断开电源	`{"power":"0"}`	断开断路器，灯箱断电
计量查询	`{"metering":""}`	查询功率、累计用电量等
状态查询	`{"get_status":""}`	查询通断状态和在线状态

2.5 计量数据查询（核心功能）

对于广告灯箱能耗统计场景，计量数据查询是最核心的功能

命令格式

返回示例（根据实际产品定义）：

2.6 完整请求示例

第三章：多语言代码实现

3.1 Python完整实现

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

# ========== 配置信息 ==========
APP_ID = "YOUR_APP_ID"           # 应用ID
APP_SECRET = "YOUR_APP_SECRET"   # 应用密钥
DEVICE_ID = "YOUR_DEVICE_ID"     # 40A断路器设备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 turn_on() -> dict:
    """接通电源，灯箱亮起"""
    return send_command({"power": "1"})

def turn_off() -> dict:
    """断开电源，灯箱熄灭"""
    return send_command({"power": "0"})

def get_power_status() -> Optional[bool]:
    """查询通断状态"""
    result = send_command({"get_status": ""})
    if result.get("error"):
        return None
    return result.get("data", {}).get("status") == "1"

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

# ========== 计量数据查询（核心功能）==========
def get_metering_data() -> Dict:
    """
    获取计量数据
    
    返回:
        {
            "power": float,     # 当前功率(W)
            "energy": float,    # 累计用电量(kWh)
            "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)),
        "energy": float(data.get("energy", 0)),
        "voltage": float(data.get("voltage", 0)),
        "current": float(data.get("current", 0)),
        "online": data.get("online") == "1",
        "raw_data": data
    }

def get_current_power() -> float:
    """获取当前功率（W）"""
    data = get_metering_data()
    return data.get("power", 0)

def get_total_energy() -> float:
    """获取累计用电量（kWh）"""
    data = get_metering_data()
    return data.get("energy", 0)

# ========== 广告灯箱控制器类 ==========
class LightboxController:
    """广告灯箱智能控制器"""
    
    def __init__(self, device_id: str, lightbox_info: dict):
        """
        初始化
        
        参数:
            device_id: 设备ID
            lightbox_info: 灯箱信息（位置、广告主等）
        """
        self.device_id = device_id
        self.lightbox_info = lightbox_info
        
    # ========== 核心控制 ==========
    def power_on(self) -> dict:
        """开启灯箱"""
        result = turn_on()
        self._log_operation("power_on", result)
        return result
    
    def power_off(self) -> dict:
        """关闭灯箱"""
        result = turn_off()
        self._log_operation("power_off", result)
        return result
    
    def get_power(self) -> float:
        """获取当前功率"""
        return get_current_power()
    
    def get_energy(self) -> float:
        """获取累计用电量"""
        return get_total_energy()
    
    def get_full_status(self) -> dict:
        """获取灯箱完整状态"""
        metering = get_metering_data()
        is_on = get_power_status()
        online = is_device_online()
        
        return {
            "lightbox_id": self.lightbox_info.get("id"),
            "location": self.lightbox_info.get("location"),
            "is_on": is_on,
            "online": online,
            "power_w": metering.get("power", 0),
            "energy_kwh": metering.get("energy", 0),
            "voltage_v": metering.get("voltage", 0),
            "current_a": metering.get("current", 0),
            "timestamp": datetime.now().isoformat()
        }
    
    # ========== 定时控制 ==========
    def schedule_on(self, time_str: str):
        """设置定时开启"""
        def job():
            self.power_on()
            print(f"[定时] {datetime.now()} - {self.lightbox_info.get('location')} 灯箱已开启")
        
        schedule.every().day.at(time_str).do(job)
        print(f"[定时] 已设置{time_str}开启灯箱")
    
    def schedule_off(self, time_str: str):
        """设置定时关闭"""
        def job():
            self.power_off()
            print(f"[定时] {datetime.now()} - {self.lightbox_info.get('location')} 灯箱已关闭")
        
        schedule.every().day.at(time_str).do(job)
        print(f"[定时] 已设置{time_str}关闭灯箱")
    
    def schedule_auto_cycle(self, on_time: str, off_time: str):
        """设置自动循环（如每天18点开，次日6点关）"""
        self.schedule_on(on_time)
        self.schedule_off(off_time)
    
    def _log_operation(self, action: str, result: dict):
        """记录操作日志"""
        log_entry = {
            "timestamp": datetime.now().isoformat(),
            "lightbox_id": self.lightbox_info.get("id"),
            "action": action,
            "success": not result.get("error"),
            "message": "成功" if not result.get("error") else result.get("error")
        }
        # 实际项目中写入数据库
        print(f"[操作日志] {log_entry}")

# ========== 能耗统计服务 ==========
class EnergyStatistics:
    """能耗统计服务"""
    
    def __init__(self, db_path: str = "lightbox_energy.db"):
        self.db_path = db_path
        self._init_database()
    
    def _init_database(self):
        """初始化数据库"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        # 计量数据明细表
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS metering_data (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                device_id TEXT NOT NULL,
                timestamp DATETIME NOT NULL,
                power REAL,
                energy REAL,
                voltage REAL,
                current REAL
            )
        ''')
        
        # 日统计表
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS daily_stats (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                device_id TEXT NOT NULL,
                stat_date DATE NOT NULL,
                total_energy REAL DEFAULT 0,
                max_power REAL DEFAULT 0,
                avg_power REAL DEFAULT 0,
                runtime_hours REAL DEFAULT 0,
                UNIQUE(device_id, stat_date)
            )
        ''')
        
        conn.commit()
        conn.close()
    
    def save_metering_data(self, device_id: str, data: dict):
        """保存计量数据"""
        if data.get("error"):
            return
        
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute('''
            INSERT INTO metering_data (device_id, timestamp, power, energy, voltage, current)
            VALUES (?, ?, ?, ?, ?, ?)
        ''', (
            device_id,
            datetime.now(),
            data.get("power"),
            data.get("energy"),
            data.get("voltage"),
            data.get("current")
        ))
        conn.commit()
        conn.close()
    
    def get_daily_energy(self, device_id: str, date: date) -> float:
        """获取指定日期的用电量"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        # 获取当天第一笔和最后一笔的累计用电量差值
        cursor.execute('''
            SELECT MIN(energy), MAX(energy) FROM metering_data
            WHERE device_id = ? AND DATE(timestamp) = ?
        ''', (device_id, str(date)))
        min_energy, max_energy = cursor.fetchone()
        conn.close()
        
        if min_energy is not None and max_energy is not None:
            return max_energy - min_energy
        return 0
    
    def get_monthly_energy(self, device_id: str, year: int, month: int) -> float:
        """获取指定月份的用电量"""
        start_date = date(year, month, 1)
        end_date = date(year + (month // 12), (month % 12) + 1, 1)
        
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute('''
            SELECT MIN(energy), MAX(energy) FROM metering_data
            WHERE device_id = ? AND DATE(timestamp) >= ? AND DATE(timestamp) < ?
        ''', (device_id, str(start_date), str(end_date)))
        min_energy, max_energy = cursor.fetchone()
        conn.close()
        
        if min_energy is not None and max_energy is not None:
            return max_energy - min_energy
        return 0

# ========== 定时采集服务 ==========
def start_collection_service(interval_seconds: int = 300):
    """启动定时采集服务（每5分钟采集一次）"""
    stats = EnergyStatistics()
    
    def collect():
        data = get_metering_data()
        if not data.get("error"):
            stats.save_metering_data(DEVICE_ID, data)
            print(f"[采集] {datetime.now()} - 功率:{data.get('power')}W, 累计:{data.get('energy')}kWh")
    
    schedule.every(interval_seconds).seconds.do(collect)
    print(f"[服务] 计量采集服务已启动，间隔{interval_seconds}秒")
    
    while True:
        schedule.run_pending()
        time.sleep(1)

# ========== 调用示例 ==========
if __name__ == "__main__":
    # 灯箱配置
    lightbox_config = {
        "id": "LB001",
        "location": "人民广场站A出口",
        "advertiser": "XX品牌"
    }
    
    # 初始化控制器
    controller = LightboxController(DEVICE_ID, lightbox_config)
    
    # ========== 基本操作示例 ==========
    # 开启灯箱
    # controller.power_on()
    
    # 查询当前功率
    # power = controller.get_power()
    # print(f"当前功率: {power}W")
    
    # 获取完整状态
    # status = controller.get_full_status()
    # print(f"灯箱状态: {status}")
    
    # ========== 定时控制示例 ==========
    # 设置每天18:00开启，次日06:00关闭
    # controller.schedule_auto_cycle("18:00", "06:00")
    
    # ========== 启动采集服务 ==========
    # start_collection_service(interval_seconds=300)

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 turnOn() {
    return sendCommand({ power: "1" });
}

async function turnOff() {
    return sendCommand({ power: "0" });
}

// 计量查询
async function getMeteringData() {
    const result = await sendCommand({ metering: "" });
    if (result.error) {
        return { error: result.error, online: false };
    }
    const data = result.data || {};
    return {
        power: parseFloat(data.power || 0),
        energy: parseFloat(data.energy || 0),
        voltage: parseFloat(data.voltage || 0),
        current: parseFloat(data.current || 0),
        online: data.online === '1'
    };
}

// 灯箱控制器类
class LightboxController {
    constructor(deviceId, lightboxInfo) {
        this.deviceId = deviceId;
        this.lightboxInfo = lightboxInfo;
    }
    
    async powerOn() {
        const result = await turnOn();
        console.log(`[${new Date().toISOString()}] ${this.lightboxInfo.location} 灯箱已开启`);
        return result;
    }
    
    async powerOff() {
        const result = await turnOff();
        console.log(`[${new Date().toISOString()}] ${this.lightboxInfo.location} 灯箱已关闭`);
        return result;
    }
    
    async getStatus() {
        const metering = await getMeteringData();
        return {
            location: this.lightboxInfo.location,
            is_on: metering.power > 0,
            power_w: metering.power,
            energy_kwh: metering.energy,
            online: metering.online
        };
    }
    
    scheduleAutoCycle(onTime, offTime) {
        // 使用node-schedule库实现定时任务
        console.log(`已设置定时:${onTime}开启，${offTime}关闭`);
    }
}

// 使用示例
// const controller = new LightboxController(config.deviceId, { location: "人民广场站" });
// controller.powerOn();

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;

public class LightboxController {
    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 turnOn() throws Exception {
        long ts = System.currentTimeMillis() / 1000;
        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 getMeteringData() throws Exception {
        long ts = System.currentTimeMillis() / 1000;
        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\":{\"metering\":\"\"}}",
            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 {
        // 开启灯箱
        turnOn();
        System.out.println("灯箱已开启");
        
        // 查询计量数据
        String metering = getMeteringData();
        System.out.println("计量数据: " + metering);
    }
}

3.4 Shell脚本（cURL）实现

第四章：广告灯箱业务场景集成

4.1 系统集成架构

广告灯箱智能控制系统可与运营管理平台深度集成：

graph TB
    subgraph 硬件层
        A[40A计量断路器]
        B[广告灯箱]
    end
    
    subgraph 采集层
        C[定时采集服务]
        D[计量数据API]
    end
    
    subgraph 存储层
        E[时序数据库]
        F[业务数据库]
    end
    
    subgraph 应用层
        G[运营看板]
        H[能耗报表]
        I[远程控制台]
        J[异常告警]
    end
    
    A -->|计量数据| C
    A -->|控制指令| I
    C --> D
    D --> E
    D --> F
    E --> G
    E --> H
    F --> I
    C --> J

4.2 第一种场景：灯箱远程集中控制

业务需求：运营人员通过管理后台远程控制多个广告灯箱的开关。

实现逻辑

管理后台展示所有灯箱列表
点击开关按钮调用API
支持批量控制和分组控制

代码实现

class LightboxGroupController:
    """多灯箱集中控制器"""
    
    def __init__(self):
        self.lightboxes = {}  # {灯箱ID: LightboxController}
    
    def add_lightbox(self, lightbox_id: str, controller: LightboxController):
        """注册灯箱"""
        self.lightboxes[lightbox_id] = controller
    
    def group_power_on(self, lightbox_ids: List[str]) -> dict:
        """批量开启指定灯箱"""
        results = {}
        for lb_id in lightbox_ids:
            if lb_id in self.lightboxes:
                results[lb_id] = self.lightboxes[lb_id].power_on()
        return results
    
    def group_power_off(self, lightbox_ids: List[str]) -> dict:
        """批量关闭指定灯箱"""
        results = {}
        for lb_id in lightbox_ids:
            if lb_id in self.lightboxes:
                results[lb_id] = self.lightboxes[lb_id].power_off()
        return results
    
    def all_on(self) -> dict:
        """全部开启"""
        return self.group_power_on(list(self.lightboxes.keys()))
    
    def all_off(self) -> dict:
        """全部关闭"""
        return self.group_power_off(list(self.lightboxes.keys()))

4.3 第二种场景：灯箱能耗实时监测

业务需求：实时监测灯箱用电功率和累计用电量，为广告投放效果评估提供数据支撑。

实现逻辑

定时采集设备计量数据
存入时序数据库
可视化展示功率曲线和能耗趋势

代码实现

4.4 第三种场景：定时自动开关（节能策略）

业务需求：广告灯箱按预设时间自动开关，实现无人值守运营。

实现逻辑

配置不同灯箱的开关时段
使用定时任务框架自动执行
支持节假日特殊时段调整

代码实现

4.5 场景四：用电异常告警

业务需求：监测到灯箱功率异常（过高或过低）时自动告警。

实现逻辑

设定功率正常范围
定时采集功率数据
超出范围触发告警

代码实现

class LightboxMonitor:
    """灯箱运行监控"""
    
    def __init__(self, expected_power_range: tuple = (100, 1000)):
        """
        参数:
            expected_power_range: 正常功率范围(W) (min, max)
        """
        self.expected_min, self.expected_max = expected_power_range
        self.alert_callbacks = []
    
    def add_alert_callback(self, callback):
        """添加告警回调"""
        self.alert_callbacks.append(callback)
    
    def check_and_alert(self):
        """检查并告警"""
        data = get_metering_data()
        
        if not data.get("online"):
            self._trigger_alert("设备离线", data)
            return
        
        power = data.get("power", 0)
        
        if power < self.expected_min and power > 0:
            self._trigger_alert(f"功率过低: {power}W < {self.expected_min}W", data)
        elif power > self.expected_max and data.get("power", 0) > 0:
            self._trigger_alert(f"功率过高: {power}W > {self.expected_max}W", data)
        elif power == 0:
            # 灯箱应该亮但功率为0
            self._trigger_alert("灯箱疑似故障，功率为0", data)
    
    def _trigger_alert(self, message: str, data: dict):
        """触发告警"""
        alert_msg = f"[{datetime.now()}] {message}"
        print(alert_msg)
        
        for callback in self.alert_callbacks:
            callback(message, data)

# 使用示例
monitor =