项目开发背景

随着智能家居技术的快速发展与普及，人们对家庭用电设备的安全性、便捷性及智能化管理提出了更高要求。传统插座功能单一，无法满足用户对电能监测、远程控制和智能联动的需求，同时家庭中仍存在大量非智能电器，难以融入现代智能家居系统。此外，用电安全问题日益突出，过载、短路等隐患亟需通过技术手段实现实时预警与防护。

在此背景下，开发一款集成电量计量、多模式控制、红外学习和智能报警功能的智能插座具有重要意义。它不仅可以帮助用户实时掌握电器能耗情况，促进节能减耗，还能通过红外自学能力将传统家电纳入智能控制范围，提升生活便利性。该项目结合本地交互与云端服务，旨在为用户构建一个安全、高效、可扩展的用电管理节点，推动家庭能源管理的智能化升级。

设计实现的功能

（1）实时电气参数监测：通过HLW8032电能计量芯片采集插座的电压、电流和功率数据，并由STM32F103C8T6单片机处理计算累计用电量，实现实时监测功能。
（2）多方式插座控制：支持通过电容触摸按键进行手动控制、通过ESP-01S WiFi模块连接手机APP进行远程控制、以及通过SYN6288语音播报模块接收AI语音指令控制插座通断，由继电器与过零固态继电器组合电路执行负载开关操作。
（3）红外自学习与控制：利用红外发射接收头实现红外自学习功能，可适配并控制传统非智能家电，由STM32F103C8T6单片机管理学习与控制流程。
（4）异常检测与报警：STM32F103C8T6单片机基于HLW8032采集的数据识别过载、过压等异常情况，触发WS2812 RGB指示灯和SYN6288语音播报模块进行本地声光报警，并通过ESP-01S WiFi模块向手机APP推送报警信息，实现双重报警。
（5）数据上传与云服务：通过ESP-01S WiFi模块将用电数据上传至云端服务器，由STM32F103C8T6单片机协调数据通信，支持历史数据查询与分析。

项目硬件模块组成

（1）主控模块：采用STM32F103C8T6单片机作为核心控制器。
（2）电量计量模块：使用HLW8032电能计量芯片采集电气参数。
（3）人机交互模块：包括电容触摸按键、WS2812 RGB指示灯、SYN6288语音播报模块及红外发射接收头。
（4）网络通信模块：采用ESP-01S WiFi模块实现物联网连接。
（5）电源与执行模块：包括HLK-PM01 AC-DC降压模块、继电器与过零固态继电器组合的负载控制电路。

设计意义

设计意义在于通过集成先进硬件与智能功能，实现插座的高效监控与控制，从而提升家庭用电的安全性、便利性与节能性。该系统以STM32F103C8T6单片机为核心，结合HLW8032电能计量芯片，实时监测电压、电流、功率及累计用电量，使用户能够精准掌握能耗情况，促进能源管理优化，减少不必要的电力浪费。

支持手动触摸、手机APP远程和AI语音指令三种控制方式，并配备红外自学习功能，可适配传统非智能家电，这极大地扩展了插座的适用场景，增强了用户体验。通过灵活的操作手段，用户无论身处何地都能便捷管理家电，同时推动老旧设备向智能化过渡，降低升级成本。

识别过载、过压等异常情况，并通过本地声光与APP推送进行双重报警，显著提升了用电安全水平。这种主动防护机制能及时预警潜在风险，防止电气火灾或设备损坏，保障家庭财产与人身安全。

通过ESP-01S WiFi模块将用电数据上传至云端服务器，支持历史数据查询与分析，为智能家居系统提供数据基础。这不仅方便用户远程监控和趋势分析，还促进了大数据应用，助力实现更智能的能源调度和家庭自动化管理。

设计思路

本设计以STM32F103C8T6单片机作为核心控制器，协调各个硬件模块实现智能插座的各项功能。该系统通过集成电量计量、人机交互、网络通信和负载控制等模块，确保实时监测、灵活控制和安全运行，所有设计均基于实际硬件配置，不引入额外功能。

电量计量模块采用HLW8032电能计量芯片，持续采集插座的电压、电流数据，并由STM32进行数据处理，计算实时功率和累计用电量。这些参数为后续的异常检测和数据分析提供基础，确保监测精度和可靠性。

人机交互模块支持多种控制方式：电容触摸按键允许用户手动操作插座通断；WS2812 RGB指示灯用于直观显示工作状态，如电源、网络连接或报警；SYN6288语音播报模块响应AI语音指令，提供语音反馈；红外发射接收头则具备自学习功能，可适配传统非智能家电，通过红外信号控制其开关，扩展插座的兼容性。

异常保护功能由STM32实时监控电量数据实现，当检测到过载或过压等情况时，系统立即触发本地声光报警，并通过网络模块向手机APP推送通知，实现双重警示机制，提升使用安全性。

网络通信模块依托ESP-01S WiFi模块，将采集的用电数据上传至云端服务器，并接收来自APP的远程控制指令。这使得用户可以随时随地查询历史数据、进行分析，并通过手机远程控制插座，实现物联网集成。

电源与执行模块由HLK-PM01 AC-DC降压模块提供稳定低压电源，确保系统各部件正常工作；负载控制电路采用继电器与过零固态继电器组合，由STM32驱动，以安全高效的方式通断插座电源，同时减少电气干扰。整个设计注重实用性和稳定性，满足功能需求。

框架图

+-------------------------------------+
|       电源输入 (AC 220V)           |
+------------------+------------------+
                   |
                   v
+-------------------------------------+
|      AC-DC电源模块 (HLK-PM01)      |
|         (降压为系统供电)           |
+-------------------------------------+
                   |
                   v
+=========================================+
|         主控模块 (STM32F103C8T6)        |
|    (核心控制器，处理数据与控制逻辑)     |
+=========================================+
         |           |           |           |
         v           v           v           v
+-------------+ +-------------+ +-------------+ +-------------------+
| 电量计量模块 | | 人机交互模块 | | 网络通信模块 | |  电源与执行模块   |
| HLW8032    | | -电容触摸按键| | ESP-01S    | | -继电器          |
| (监测电压、  | | -WS2812 RGB | | WiFi模块   | | -过零固态继电器  |
| 电流、功率、| |   指示灯     | | (连接云端) | | (控制插座通断)   |
| 累计用电量) | | -SYN6288语音| |            | |                  |
|             | |   播报模块   | |            | |                  |
|             | | -红外发射    | |            | +-------------------+
|             | |   接收头     | |            |         |
+-------------+ +-------------+ +-------------+         |
         |           |           |           |         v
         |           |           |           | +-------------------+
         |           |           |           | |   插座负载输出    |
         |           |           |           | | (连接家电设备)    |
         |           |           |           | +-------------------+
         |           |           |           |
         v           v           v           v
+-------------+ +-------------+ +-------------+ +-------------------+
| 数据采集与   | | 用户交互接口 | | 云端通信接口 | | 负载控制与保护   |
| 处理        | | -手动触摸控制| | -上传用电   | | -过载/过压检测  |
| (实时监测)  | | -本地声光   | |   数据      | | -异常报警触发   |
|             | |   报警      | | -接收远程  | |   (本地与APP)    |
|             | | -红外自学习 | |   控制指令  | |                  |
|             | |   与控制    | | (APP/AI语音)| |                  |
+-------------+ +-------------+ +-------------+ +-------------------+
                                   |
                                   v
                          +-------------------+
                          |   云端服务器      |
                          | (存储与分析数据,  |
                          |  支持历史查询)    |
                          +-------------------+
                                   |
                                   v
                          +-------------------+
                          |   手机APP界面     |
                          | (远程控制、状态   |
                          |  监控、报警推送)  |
                          +-------------------+

系统框架图说明：

• 电源输入：提供AC电源，经HLK-PM01模块降压后为整个系统供电。
• 主控模块：STM32F103C8T6作为核心，协调所有模块的运行。
• 电量计量模块：HLW8032实时采集插座的电气参数，传输给主控处理。
• 人机交互模块：集成触摸控制、状态指示、语音反馈和红外学习功能，支持手动与红外控制。
• 网络通信模块：ESP-01S WiFi模块连接云端，实现数据上传和远程指令接收。
• 电源与执行模块：继电器组合控制插座通断，并集成过载/过压保护，触发本地与APP报警。
• 云端与APP：云端服务器存储数据，手机APP提供远程控制、数据查询和报警推送接口。AI语音指令通过APP或云端集成，经WiFi模块传输至主控。

系统总体设计

系统总体设计基于STM32F103C8T6单片机作为核心控制器，协调各硬件模块实现智能插座的综合功能。该系统集成电量计量、人机交互、网络通信及电源执行模块，确保实时监测与控制，同时保障安全性和可靠性。

电量监测功能通过HLW8032电能计量芯片实现，该芯片采集插座的电压、电流和功率数据，并传输至主控模块进行实时计算与累计用电量统计。主控模块持续监控这些参数，一旦检测到过载或过压等异常情况，便触发报警机制。

控制机制支持多种方式，包括手动触摸通过电容触摸按键操作、手机APP远程指令经由Wi-Fi模块传输，以及AI语音指令通过SYN6288语音播报模块处理。此外，红外发射接收头具备自学习功能，可适配传统非智能家电，实现红外遥控控制。WS2812 RGB指示灯提供状态反馈，增强用户交互体验。

报警与通信部分由本地声光报警和APP推送双重实现，当识别异常时，主控模块驱动指示灯和语音模块进行本地警示，同时通过网络通信模块发送警报至云端。ESP-01S Wi-Fi模块负责将用电数据上传至云端服务器，支持历史数据查询与分析，确保用户可远程访问和管理。

电源与执行模块采用HLK-PM01 AC-DC降压模块为系统提供稳定电源，而继电器与过零固态继电器组合的负载控制电路负责插座通断操作，确保高效且安全的负载管理。整个系统通过模块化设计，实现数据采集、控制响应与云端通信的无缝集成，满足实时性与稳定性的需求。

系统功能总结

设计的各个功能模块描述

主控模块采用STM32F103C8T6单片机作为核心控制器，负责协调系统各模块的运行，处理电量计量数据、执行控制逻辑并管理通信协议，确保实时监测与控制功能的实现。

电量计量模块使用HLW8032电能计量芯片，通过采集电压和电流信号，计算功率及累计用电量，为系统提供准确的电气参数监测数据。

人机交互模块包括电容触摸按键用于手动控制插座通断，WS2812 RGB指示灯用于显示工作状态和报警提示，SYN6288语音播报模块支持AI语音指令反馈和报警播报，红外发射接收头则实现红外自学习功能，适配并控制传统非智能家电。

网络通信模块采用ESP-01S WiFi模块，通过Wi-Fi连接将用电数据上传至云端服务器，支持手机APP远程控制、历史数据查询与分析，并接收云端指令以实现远程操作。

电源与执行模块包含HLK-PM01 AC-DC降压模块为系统提供稳定直流电源，继电器与过零固态继电器组合构成负载控制电路，实现插座的安全通断控制，并在过载或过压时触发本地声光报警及APP推送。

上位机代码设计

由于项目涉及物联网与硬件通信，上位机需要实现设备监控、控制、报警处理与数据分析功能。以下是基于C++/Qt开发的上位机完整代码设计，包含主界面、通信管理、数据处理和UI组件：

// main.cpp - 应用程序入口
#include "mainwindow.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    MainWindow w;
    w.show();
    return app.exec();
}

// device.h - 设备数据结构定义
#pragma once
#include <QString>
#include <QDateTime>

struct DeviceStatus {
    float voltage;      // 电压(V)
    float current;      // 电流(A)
    float power;        // 功率(W)
    float energy;       // 累计电量(kWh)
    bool relayState;    // 继电器状态
    bool overload;      // 过载状态
    bool overvoltage;   // 过压状态
    QDateTime timestamp;
};

struct DeviceConfig {
    QString deviceId;
    QString deviceName;
    float overloadThreshold;    // 过载阈值(W)
    float overvoltageThreshold; // 过压阈值(V)
    QString wifiSSID;
    QString wifiPassword;
};

// communicationmanager.h - 通信管理类
#pragma once
#include <QObject>
#include <QTcpSocket>
#include <QSerialPort>
#include <QTimer>
#include "device.h"

class CommunicationManager : public QObject
{
    Q_OBJECT
public:
    enum ConnectionType { TCP, MQTT, SERIAL };
    
    explicit CommunicationManager(QObject *parent = nullptr);
    ~CommunicationManager();
    
    bool connectToDevice(const QString &address, int port = 1883);
    bool connectSerial(const QString &portName, int baudRate = 115200);
    void disconnectDevice();
    
    void sendControlCommand(bool powerOn);
    void sendInfraredLearn();
    void sendInfraredCommand(const QByteArray &irData);
    void requestDeviceStatus();
    
    void updateConfig(const DeviceConfig &config);
    
signals:
    void deviceStatusUpdated(const DeviceStatus &status);
    void deviceConnected();
    void deviceDisconnected();
    void alertReceived(const QString &alertType, const QString &message);
    void connectionError(const QString &error);
    
private slots:
    void onTcpReadyRead();
    void onSerialReadyRead();
    void onReconnectTimeout();
    
private:
    void parseData(const QByteArray &data);
    void sendData(const QByteArray &data);
    QByteArray encodeCommand(const QByteArray &command);
    
    QTcpSocket *tcpSocket;
    QSerialPort *serialPort;
    QTimer *reconnectTimer;
    ConnectionType currentType;
    bool isConnected;
    QString deviceAddress;
    int devicePort;
    
    // 通信协议定义
    const QByteArray PACKET_HEADER = QByteArray::fromHex("AA55");
    const QByteArray PACKET_FOOTER = QByteArray::fromHex("55AA");
    const quint8 CMD_STATUS = 0x01;
    const quint8 CMD_CONTROL = 0x02;
    const quint8 CMD_ALERT = 0x03;
    const quint8 CMD_INFRARED = 0x04;
};

// communicationmanager.cpp
#include "communicationmanager.h"
#include <QDebug>
#include <QJsonDocument>
#include <QJsonObject>

CommunicationManager::CommunicationManager(QObject *parent)
    : QObject(parent)
    , tcpSocket(nullptr)
    , serialPort(nullptr)
    , reconnectTimer(new QTimer(this))
    , currentType(TCP)
    , isConnected(false)
{
    reconnectTimer->setInterval(5000);
    connect(reconnectTimer, &QTimer::timeout, this, &CommunicationManager::onReconnectTimeout);
}

bool CommunicationManager::connectToDevice(const QString &address, int port)
{
    if (isConnected) disconnectDevice();
    
    deviceAddress = address;
    devicePort = port;
    currentType = TCP;
    
    tcpSocket = new QTcpSocket(this);
    connect(tcpSocket, &QTcpSocket::connected, this, [this]() {
        isConnected = true;
        reconnectTimer->stop();
        connect(tcpSocket, &QTcpSocket::readyRead, this, &CommunicationManager::onTcpReadyRead);
        emit deviceConnected();
        qDebug() << "TCP Connected to" << deviceAddress << ":" << devicePort;
    });
    
    connect(tcpSocket, &QTcpSocket::disconnected, this, [this]() {
        isConnected = false;
        emit deviceDisconnected();
        reconnectTimer->start();
        qDebug() << "TCP Disconnected";
    });
    
    connect(tcpSocket, QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::errorOccurred),
            this, [this](QAbstractSocket::SocketError error) {
        emit connectionError(tcpSocket->errorString());
    });
    
    tcpSocket->connectToHost(address, port);
    return true;
}

bool CommunicationManager::connectSerial(const QString &portName, int baudRate)
{
    if (isConnected) disconnectDevice();
    
    currentType = SERIAL;
    serialPort = new QSerialPort(this);
    serialPort->setPortName(portName);
    serialPort->setBaudRate(baudRate);
    serialPort->setDataBits(QSerialPort::Data8);
    serialPort->setParity(QSerialPort::NoParity);
    serialPort->setStopBits(QSerialPort::OneStop);
    serialPort->setFlowControl(QSerialPort::NoFlowControl);
    
    if (serialPort->open(QIODevice::ReadWrite)) {
        isConnected = true;
        connect(serialPort, &QSerialPort::readyRead, this, &CommunicationManager::onSerialReadyRead);
        emit deviceConnected();
        qDebug() << "Serial Connected to" << portName;
        return true;
    } else {
        emit connectionError(serialPort->errorString());
        return false;
    }
}

void CommunicationManager::disconnectDevice()
{
    if (tcpSocket && tcpSocket->state() == QAbstractSocket::ConnectedState) {
        tcpSocket->disconnectFromHost();
        tcpSocket->deleteLater();
        tcpSocket = nullptr;
    }
    
    if (serialPort && serialPort->isOpen()) {
        serialPort->close();
        serialPort->deleteLater();
        serialPort = nullptr;
    }
    
    isConnected = false;
    reconnectTimer->stop();
}

void CommunicationManager::sendControlCommand(bool powerOn)
{
    QByteArray command;
    command.append(CMD_CONTROL);
    command.append(powerOn ? 0x01 : 0x00);
    sendData(command);
}

void CommunicationManager::sendInfraredLearn()
{
    QByteArray command;
    command.append(CMD_INFRARED);
    command.append(0x01); // 学习模式
    sendData(command);
}

void CommunicationManager::sendInfraredCommand(const QByteArray &irData)
{
    QByteArray command;
    command.append(CMD_INFRARED);
    command.append(0x02); // 发射模式
    command.append(irData);
    sendData(command);
}

void CommunicationManager::requestDeviceStatus()
{
    QByteArray command;
    command.append(CMD_STATUS);
    sendData(command);
}

void CommunicationManager::onTcpReadyRead()
{
    QByteArray data = tcpSocket->readAll();
    parseData(data);
}

void CommunicationManager::onSerialReadyRead()
{
    QByteArray data = serialPort->readAll();
    parseData(data);
}

void CommunicationManager::parseData(const QByteArray &data)
{
    // 查找数据包
    int startIdx = data.indexOf(PACKET_HEADER);
    if (startIdx == -1) return;
    
    // 跳过包头
    QByteArray packet = data.mid(startIdx + PACKET_HEADER.size());
    
    // 检查包尾
    int endIdx = packet.indexOf(PACKET_FOOTER);
    if (endIdx == -1) return;
    
    packet = packet.left(endIdx);
    
    if (packet.size() < 2) return;
    
    quint8 cmd = packet[0];
    quint8 len = packet[1];
    
    if (packet.size() < 2 + len) return;
    
    QByteArray payload = packet.mid(2, len);
    
    switch (cmd) {
    case CMD_STATUS: {
        if (payload.size() >= 12) {
            DeviceStatus status;
            status.voltage = (quint16(payload[0]) << 8 | quint8(payload[1])) / 10.0;
            status.current = (quint16(payload[2]) << 8 | quint8(payload[3])) / 1000.0;
            status.power = (quint16(payload[4]) << 8 | quint8(payload[5])) / 10.0;
            status.energy = (quint32(payload[6]) << 24 | quint32(payload[7]) << 16 | 
                           quint32(payload[8]) << 8 | quint32(payload[9])) / 10.0;
            status.relayState = payload[10] & 0x01;
            status.overload = payload[10] & 0x02;
            status.overvoltage = payload[10] & 0x04;
            status.timestamp = QDateTime::currentDateTime();
            
            emit deviceStatusUpdated(status);
        }
        break;
    }
    case CMD_ALERT: {
        if (payload.size() >= 2) {
            QString alertType;
            switch (payload[0]) {
            case 0x01: alertType = "过载报警"; break;
            case 0x02: alertType = "过压报警"; break;
            case 0x03: alertType = "温度过高"; break;
            default: alertType = "未知报警";
            }
            emit alertReceived(alertType, QString("设备报警: %1").arg(alertType));
        }
        break;
    }
    }
}

void CommunicationManager::sendData(const QByteArray &data)
{
    if (!isConnected) return;
    
    QByteArray packet = encodeCommand(data);
    
    switch (currentType) {
    case TCP:
        if (tcpSocket) tcpSocket->write(packet);
        break;
    case SERIAL:
        if (serialPort) serialPort->write(packet);
        break;
    default:
        break;
    }
}

QByteArray CommunicationManager::encodeCommand(const QByteArray &command)
{
    QByteArray packet;
    packet.append(PACKET_HEADER);
    packet.append(command);
    
    // 计算校验和
    quint8 checksum = 0;
    for (char c : command) {
        checksum += quint8(c);
    }
    packet.append(checksum);
    packet.append(PACKET_FOOTER);
    
    return packet;
}

void CommunicationManager::onReconnectTimeout()
{
    if (currentType == TCP) {
        connectToDevice(deviceAddress, devicePort);
    }
}

void CommunicationManager::updateConfig(const DeviceConfig &config)
{
    QJsonObject json;
    json["deviceId"] = config.deviceId;
    json["overloadThreshold"] = config.overloadThreshold;
    json["overvoltageThreshold"] = config.overvoltageThreshold;
    
    QJsonDocument doc(json);
    QByteArray data = doc.toJson();
    
    QByteArray command;
    command.append(quint8(0x05)); // 配置命令
    command.append(data);
    
    sendData(command);
}

// datamanager.h - 数据管理类
#pragma once
#include <QObject>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QVector>
#include "device.h"

class DataManager : public QObject
{
    Q_OBJECT
public:
    explicit DataManager(QObject *parent = nullptr);
    ~DataManager();
    
    bool initDatabase(const QString &dbPath = "smart_socket.db");
    void saveDeviceStatus(const DeviceStatus &status);
    QVector<DeviceStatus> queryHistory(const QDateTime &start, const QDateTime &end);
    DeviceStatus getLatestStatus();
    
    // 统计分析
    double calculateEnergyConsumption(const QDateTime &start, const QDateTime &end);
    QVector<QPair<QDateTime, double>> getPowerTrend(int hours = 24);
    QVector<QPair<QString, double>> getDailyEnergy(int days = 7);
    
private:
    QSqlDatabase database;
    bool createTables();
};

// datamanager.cpp
#include "datamanager.h"
#include <QDebug>
#include <QSqlError>
#include <QSqlRecord>

DataManager::DataManager(QObject *parent)
    : QObject(parent)
{
}

bool DataManager::initDatabase(const QString &dbPath)
{
    database = QSqlDatabase::addDatabase("QSQLITE");
    database.setDatabaseName(dbPath);
    
    if (!database.open()) {
        qDebug() << "Database error:" << database.lastError().text();
        return false;
    }
    
    return createTables();
}

bool DataManager::createTables()
{
    QSqlQuery query;
    
    // 设备状态表
    QString createTable = R"(
        CREATE TABLE IF NOT EXISTS device_status (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            timestamp DATETIME NOT NULL,
            voltage REAL,
            current REAL,
            power REAL,
            energy REAL,
            relay_state INTEGER,
            overload INTEGER,
            overvoltage INTEGER
        )
    )";
    
    if (!query.exec(createTable)) {
        qDebug() << "Create table error:" << query.lastError().text();
        return false;
    }
    
    // 创建索引
    query.exec("CREATE INDEX IF NOT EXISTS idx_timestamp ON device_status(timestamp)");
    
    return true;
}

void DataManager::saveDeviceStatus(const DeviceStatus &status)
{
    QSqlQuery query;
    query.prepare(R"(
        INSERT INTO device_status 
        (timestamp, voltage, current, power, energy, relay_state, overload, overvoltage)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
    )");
    
    query.addBindValue(status.timestamp);
    query.addBindValue(status.voltage);
    query.addBindValue(status.current);
    query.addBindValue(status.power);
    query.addBindValue(status.energy);
    query.addBindValue(status.relayState ? 1 : 0);
    query.addBindValue(status.overload ? 1 : 0);
    query.addBindValue(status.overvoltage ? 1 : 0);
    
    if (!query.exec()) {
        qDebug() << "Insert error:" << query.lastError().text();
    }
}

QVector<DeviceStatus> DataManager::queryHistory(const QDateTime &start, const QDateTime &end)
{
    QVector<DeviceStatus> history;
    
    QSqlQuery query;
    query.prepare(R"(
        SELECT * FROM device_status 
        WHERE timestamp BETWEEN ? AND ? 
        ORDER BY timestamp ASC
    )");
    
    query.addBindValue(start);
    query.addBindValue(end);
    
    if (query.exec()) {
        while (query.next()) {
            DeviceStatus status;
            status.timestamp = query.value("timestamp").toDateTime();
            status.voltage = query.value("voltage").toFloat();
            status.current = query.value("current").toFloat();
            status.power = query.value("power").toFloat();
            status.energy = query.value("energy").toFloat();
            status.relayState = query.value("relay_state").toInt() == 1;
            status.overload = query.value("overload").toInt() == 1;
            status.overvoltage = query.value("overvoltage").toInt() == 1;
            
            history.append(status);
        }
    }
    
    return history;
}

DeviceStatus DataManager::getLatestStatus()
{
    DeviceStatus status;
    
    QSqlQuery query("SELECT * FROM device_status ORDER BY timestamp DESC LIMIT 1");
    if (query.next()) {
        status.timestamp = query.value("timestamp").toDateTime();
        status.voltage = query.value("voltage").toFloat();
        status.current = query.value("current").toFloat();
        status.power = query.value("power").toFloat();
        status.energy = query.value("energy").toFloat();
        status.relayState = query.value("relay_state").toInt() == 1;
        status.overload = query.value("overload").toInt() == 1;
        status.overvoltage = query.value("overvoltage").toInt() == 1;
    }
    
    return status;
}

double DataManager::calculateEnergyConsumption(const QDateTime &start, const QDateTime &end)
{
    QSqlQuery query;
    query.prepare(R"(
        SELECT MAX(energy) - MIN(energy) as consumption 
        FROM device_status 
        WHERE timestamp BETWEEN ? AND ?
    )");
    
    query.addBindValue(start);
    query.addBindValue(end);
    
    if (query.exec() && query.next()) {
        return query.value("consumption").toDouble();
    }
    
    return 0.0;
}

QVector<QPair<QDateTime, double>> DataManager::getPowerTrend(int hours)
{
    QVector<QPair<QDateTime, double>> trend;
    
    QSqlQuery query;
    query.prepare(R"(
        SELECT strftime('%Y-%m-%d %H:00:00', timestamp) as hour_time,
               AVG(power) as avg_power
        FROM device_status
        WHERE timestamp >= datetime('now', ?)
        GROUP BY hour_time
        ORDER BY hour_time ASC
    )");
    
    query.addBindValue(QString("-%1 hours").arg(hours));
    
    if (query.exec()) {
        while (query.next()) {
            QDateTime time = QDateTime::fromString(query.value("hour_time").toString(), 
                                                   "yyyy-MM-dd HH:mm:ss");
            double power = query.value("avg_power").toDouble();
            trend.append(qMakePair(time, power));
        }
    }
    
    return trend;
}

DataManager::~DataManager()
{
    if (database.isOpen()) {
        database.close();
    }
}

// mainwindow.h - 主窗口类
#pragma once
#include <QMainWindow>
#include <QTimer>
#include <QChartView>
#include <QLineSeries>
#include "communicationmanager.h"
#include "datamanager.h"

QT_CHARTS_USE_NAMESPACE

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

private slots:
    void onConnectClicked();
    void onDisconnectClicked();
    void onPowerControlClicked();
    void onInfraredLearnClicked();
    void onInfraredSendClicked();
    void onUpdateIntervalChanged(int value);
    
    void onDeviceConnected();
    void onDeviceDisconnected();
    void onDeviceStatusUpdated(const DeviceStatus &status);
    void onAlertReceived(const QString &alertType, const QString &message);
    void onConnectionError(const QString &error);
    
    void updateCharts();
    void saveSettings();
    void loadSettings();
    
private:
    void setupUI();
    void setupCharts();
    void updateStatusDisplay(const DeviceStatus &status);
    void showAlert(const QString &message);
    
    Ui::MainWindow *ui;
    CommunicationManager *commManager;
    DataManager *dataManager;
    QTimer *updateTimer;
    
    // 图表相关
    QChart *powerChart;
    QLineSeries *powerSeries;
    QChart *energyChart;
    QLineSeries *energySeries;
    
    // 数据缓冲区
    QVector<QPair<QDateTime, double>> powerHistory;
    QVector<QPair<QDateTime, double>> energyHistory;
    
    DeviceStatus currentStatus;
    DeviceConfig deviceConfig;
};

// mainwindow.cpp
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QDateTime>
#include <QMessageBox>
#include <QSerialPortInfo>
#include <QSettings>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
    , commManager(new CommunicationManager(this))
    , dataManager(new DataManager(this))
    , updateTimer(new QTimer(this))
    , powerChart(new QChart())
    , powerSeries(new QLineSeries())
    , energyChart(new QChart())
    , energySeries(new QLineSeries())
{
    ui->setupUi(this);
    setupUI();
    setupCharts();
    loadSettings();
    
    // 初始化数据库
    dataManager->initDatabase();
    
    // 连接信号槽
    connect(commManager, &CommunicationManager::deviceConnected, 
            this, &MainWindow::onDeviceConnected);
    connect(commManager, &CommunicationManager::deviceDisconnected, 
            this, &MainWindow::onDeviceDisconnected);
    connect(commManager, &CommunicationManager::deviceStatusUpdated, 
            this, &MainWindow::onDeviceStatusUpdated);
    connect(commManager, &CommunicationManager::alertReceived, 
            this, &MainWindow::onAlertReceived);
    connect(commManager, &CommunicationManager::connectionError, 
            this, &MainWindow::onConnectionError);
    
    connect(updateTimer, &QTimer::timeout, [this]() {
        if (commManager) {
            commManager->requestDeviceStatus();
        }
    });
    
    updateTimer->start(2000); // 2秒更新一次
}

void MainWindow::setupUI()
{
    // 填充串口列表
    QList<QSerialPortInfo> ports = QSerialPortInfo::availablePorts();
    foreach (const QSerialPortInfo &port, ports) {
        ui->comPortComboBox->addItem(port.portName());
    }
    
    // 设置控件属性
    ui->powerButton->setCheckable(true);
    ui->powerButton->setIcon(QIcon(":/icons/power.png"));
    
    // 连接按钮信号
    connect(ui->connectButton, &QPushButton::clicked, 
            this, &MainWindow::onConnectClicked);
    connect(ui->disconnectButton, &QPushButton::clicked, 
            this, &MainWindow::onDisconnectClicked);
    connect(ui->powerButton, &QPushButton::clicked, 
            this, &MainWindow::onPowerControlClicked);
    connect(ui->infraredLearnButton, &QPushButton::clicked, 
            this, &MainWindow::onInfraredLearnClicked);
    connect(ui->infraredSendButton, &QPushButton::clicked, 
            this, &MainWindow::onInfraredSendClicked);
    connect(ui->updateIntervalSlider, &QSlider::valueChanged, 
            this, &MainWindow::onUpdateIntervalChanged);
}

void MainWindow::setupCharts()
{
    // 功率图表
    powerSeries->setName("实时功率");
    powerChart->addSeries(powerSeries);
    powerChart->createDefaultAxes();
    powerChart->setTitle("功率趋势");
    powerChart->axisX()->setTitleText("时间");
    powerChart->axisY()->setTitleText("功率(W)");
    powerChart->legend()->setVisible(true);
    
    ui->powerChartView->setChart(powerChart);
    ui->powerChartView->setRenderHint(QPainter::Antialiasing);
    
    // 能耗图表
    energySeries->setName("累计能耗");
    energyChart->addSeries(energySeries);
    energyChart->createDefaultAxes();
    energyChart->setTitle("能耗统计");
    energyChart->axisX()->setTitleText("时间");
    energyChart->axisY()->setTitleText("电量(kWh)");
    energyChart->legend()->setVisible(true);
    
    ui->energyChartView->setChart(energyChart);
    ui->energyChartView->setRenderHint(QPainter::Antialiasing);
}

void MainWindow::onConnectClicked()
{
    QString connectionType = ui->connectionTypeComboBox->currentText();
    
    if (connectionType == "TCP") {
        QString ip = ui->ipAddressEdit->text();
        int port = ui->portSpinBox->value();
        commManager->connectToDevice(ip, port);
    } else if (connectionType == "串口") {
        QString portName = ui->comPortComboBox->currentText();
        int baudRate = ui->baudRateComboBox->currentText().toInt();
        commManager->connectSerial(portName, baudRate);
    }
}

void MainWindow::onDisconnectClicked()
{
    commManager->disconnectDevice();
}

void MainWindow::onPowerControlClicked()
{
    bool powerOn = ui->powerButton->isChecked();
    commManager->sendControlCommand(powerOn);
    ui->powerButton->setText(powerOn ? "关闭插座" : "打开插座");
}

void MainWindow::onInfraredLearnClicked()
{
    commManager->sendInfraredLearn();
    QMessageBox::information(this, "红外学习", "请将红外遥控器对准设备，按下需要学习的按键");
}

void MainWindow::onInfraredSendClicked()
{
    QString command = ui->infraredCommandEdit->text();
    if (!command.isEmpty()) {
        commManager->sendInfraredCommand(command.toUtf8());
    }
}

void MainWindow::onUpdateIntervalChanged(int value)
{
    updateTimer->setInterval(value * 1000);
    ui->updateIntervalLabel->setText(QString("%1秒").arg(value));
}

void MainWindow::onDeviceConnected()
{
    ui->statusLabel->setText("已连接");
    ui->statusLabel->setStyleSheet("color: green; font-weight: bold;");
    ui->connectButton->setEnabled(false);
    ui->disconnectButton->setEnabled(true);
    ui->controlGroupBox->setEnabled(true);
}

void MainWindow::onDeviceDisconnected()
{
    ui->statusLabel->setText("未连接");
    ui->statusLabel->setStyleSheet("color: red;");
    ui->connectButton->setEnabled(true);
    ui->disconnectButton->setEnabled(false);
    ui->controlGroupBox->setEnabled(false);
}

void MainWindow::onDeviceStatusUpdated(const DeviceStatus &status)
{
    currentStatus = status;
    updateStatusDisplay(status);
    dataManager->saveDeviceStatus(status);
    
    // 更新图表数据
    QDateTime now = QDateTime::currentDateTime();
    powerHistory.append(qMakePair(now, status.power));
    energyHistory.append(qMakePair(now, status.energy));
    
    // 保持最近100个数据点
    if (powerHistory.size() > 100) {
        powerHistory.removeFirst();
        energyHistory.removeFirst();
    }
    
    updateCharts();
    
    // 检查报警
    if (status.overload) {
        showAlert("过载报警：功率超过安全阈值！");
    }
    if (status.overvoltage) {
        showAlert("过压报警：电压超过安全阈值！");
    }
}

void MainWindow::updateStatusDisplay(const DeviceStatus &status)
{
    ui->voltageLabel->setText(QString("%1 V").arg(status.voltage, 0, 'f', 1));
    ui->currentLabel->setText(QString("%1 A").arg(status.current, 0, 'f', 3));
    ui->powerLabel->setText(QString("%1 W").arg(status.power, 0, 'f', 1));
    ui->energyLabel->setText(QString("%1 kWh").arg(status.energy, 0, 'f', 2));
    
    ui->relayStatusLabel->setText(status.relayState ? "开启" : "关闭");
    ui->relayStatusLabel->setStyleSheet(
        status.relayState ? "color: green;" : "color: red;");
    
    ui->overloadIndicator->setChecked(status.overload);
    ui->overvoltageIndicator->setChecked(status.overvoltage);
    
    ui->powerButton->setChecked(status.relayState);
    ui->powerButton->setText(status.relayState ? "关闭插座" : "打开插座");
}

void MainWindow::updateCharts()
{
    // 更新功率图表
    powerSeries->clear();
    for (int i = 0; i < powerHistory.size(); ++i) {
        qint64 msecs = powerHistory[i].first.toMSecsSinceEpoch();
        powerSeries->append(msecs, powerHistory[i].second);
    }
    
    // 更新能耗图表
    energySeries->clear();
    for (int i = 0; i < energyHistory.size(); ++i) {
        qint64 msecs = energyHistory[i].first.toMSecsSinceEpoch();
        energySeries->append(msecs, energyHistory[i].second);
    }
    
    // 更新图表显示
    powerChart->axisX()->setRange(
        QDateTime::currentDateTime().addSecs(-300), 
        QDateTime::currentDateTime());
    ui->powerChartView->update();
    ui->energyChartView->update();
}

void MainWindow::onAlertReceived(const QString &alertType, const QString &message)
{
    showAlert(QString("%1: %2").arg(alertType, message));
    
    // 添加到报警历史
    QString history = ui->alertHistoryTextEdit->toPlainText();
    QString newEntry = QString("[%1] %2\n")
        .arg(QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss"))
        .arg(message);
    ui->alertHistoryTextEdit->setPlainText(newEntry + history);
    
    // 闪烁报警指示灯
    ui->alertIndicator->setChecked(true);
    QTimer::singleShot(1000, [this]() {
        ui->alertIndicator->setChecked(false);
    });
}

void MainWindow::onConnectionError(const QString &error)
{
    QMessageBox::warning(this, "连接错误", error);
    onDeviceDisconnected();
}

void MainWindow::showAlert(const QString &message)
{
    QMessageBox::warning(this, "设备报警", message);
    
    // 系统托盘通知
    if (QSystemTrayIcon::isSystemTrayAvailable()) {
        QSystemTrayIcon::showMessage("智能插座报警", message, 
                                    QSystemTrayIcon::Warning, 3000);
    }
}

void MainWindow::saveSettings()
{
    QSettings settings("SmartSocket", "Config");
    settings.setValue("Connection/Type", ui->connectionTypeComboBox->currentIndex());
    settings.setValue("Connection/IP", ui->ipAddressEdit->text());
    settings.setValue("Connection/Port", ui->portSpinBox->value());
    settings.setValue("Connection/ComPort", ui->comPortComboBox->currentText());
    settings.setValue("Connection/BaudRate", ui->baudRateComboBox->currentIndex());
    settings.setValue("Update/Interval", ui->updateIntervalSlider->value());
}

void MainWindow::loadSettings()
{
    QSettings settings("SmartSocket", "Config");
    ui->connectionTypeComboBox->setCurrentIndex(
        settings.value("Connection/Type", 0).toInt());
    ui->ipAddressEdit->setText(
        settings.value("Connection/IP", "192.168.1.100").toString());
    ui->portSpinBox->setValue(
        settings.value("Connection/Port", 1883).toInt());
    ui->comPortComboBox->setCurrentText(
        settings.value("Connection/ComPort", "COM3").toString());
    ui->baudRateComboBox->setCurrentIndex(
        settings.value("Connection/BaudRate", 4).toInt());
    ui->updateIntervalSlider->setValue(
        settings.value("Update/Interval", 2).toInt());
}

MainWindow::~MainWindow()
{
    saveSettings();
    delete ui;
}

// smart_socket.pro - Qt项目文件
QT += core gui serialport network sql charts

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

CONFIG += c++11

SOURCES += \
    main.cpp \
    communicationmanager.cpp \
    datamanager.cpp \
    mainwindow.cpp

HEADERS += \
    communicationmanager.h \
    datamanager.h \
    device.h \
    mainwindow.h

FORMS += \
    mainwindow.ui

# 资源文件
RESOURCES += \
    resources.qrc

# 默认规则
DESTDIR = $$_PRO_FILE_PWD_/bin
OBJECTS_DIR = $$_PRO_FILE_PWD_/temp
MOC_DIR = $$_PRO_FILE_PWD_/temp
RCC_DIR = $$_PRO_FILE_PWD_/temp
UI_DIR = $$_PRO_FILE_PWD_/temp

<!-- mainwindow.ui - UI界面定义（简化版） -->
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>MainWindow</class>
 <widget class="QMainWindow" name="MainWindow">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>1200</width>
    <height>800</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>智能插座监控系统</string>
  </property>
  <widget class="QWidget" name="centralWidget">
   <layout class="QGridLayout" name="gridLayout">
    <!-- 连接控制区域 -->
    <widget class="QGroupBox" name="connectionGroupBox">
     <property name="title">
      <string>连接设置</string>
     </property>
     <layout class="QHBoxLayout">
      <widget class="QComboBox" name="connectionTypeComboBox">
       <item>
        <property name="text">
         <string>TCP</string>
        </property>
       </item>
       <item>
        <property name="text">
         <string>串口</string>
        </property>
       </item>
      </widget>
      <widget class="QLineEdit" name="ipAddressEdit"/>
      <widget class="QSpinBox" name="portSpinBox"/>
      <widget class="QComboBox" name="comPortComboBox"/>
      <widget class="QComboBox" name="baudRateComboBox">
       <item>
        <property name="text">
         <string>9600</string>
        </property>
       </item>
       <item>
        <property name="text">
         <string>115200</string>
        </property>
       </item>
      </widget>
      <widget class="QPushButton" name="connectButton">
       <property name="text">
        <string>连接</string>
       </property>
      </widget>
      <widget class="QPushButton" name="disconnectButton">
       <property name="text">
        <string>断开</string>
       </property>
      </widget>
     </layout>
    </widget>
    
    <!-- 状态显示区域 -->
    <widget class="QGroupBox" name="statusGroupBox">
     <property name="title">
      <string>实时状态</string>
     </property>
     <layout class="QGridLayout">
      <widget class="QLabel" name="voltageLabel"/>
      <widget class="QLabel" name="currentLabel"/>
      <widget class="QLabel" name="powerLabel"/>
      <widget class="QLabel" name="energyLabel"/>
      <widget class="QLabel" name="relayStatusLabel"/>
      <widget class="QCheckBox" name="overloadIndicator"/>
      <widget class="QCheckBox" name="overvoltageIndicator"/>
     </layout>
    </widget>
    
    <!-- 控制区域 -->
    <widget class="QGroupBox" name="controlGroupBox">
     <property name="title">
      <string>设备控制</string>
     </property>
     <layout class="QVBoxLayout">
      <widget class="QPushButton" name="powerButton"/>
      <widget class="QPushButton" name="infraredLearnButton">
       <property name="text">
        <string>红外学习</string>
       </property>
      </widget>
      <widget class="QLineEdit" name="infraredCommandEdit"/>
      <widget class="QPushButton" name="infraredSendButton">
       <property name="text">
        <string>发送红外</string>
       </property>
      </widget>
     </layout>
    </widget>
    
    <!-- 图表区域 -->
    <widget class="QChartView" name="powerChartView"/>
    <widget class="QChartView" name="energyChartView"/>
    
    <!-- 报警历史 -->
    <widget class="QGroupBox" name="alertGroupBox">
     <property name="title">
      <string>报警历史</string>
     </property>
     <widget class="QTextEdit" name="alertHistoryTextEdit"/>
    </widget>
    
    <!-- 状态栏 -->
    <widget class="QStatusBar" name="statusBar">
     <widget class="QLabel" name="statusLabel"/>
     <widget class="QSlider" name="updateIntervalSlider"/>
     <widget class="QLabel" name="updateIntervalLabel"/>
    </widget>
   </layout>
  </widget>
 </widget>
 <resources/>
 <connections/>
</ui>

这个完整的C++/Qt上位机系统包含以下功能模块：

1. 通信管理：支持TCP和串口两种通信方式，实现与智能插座的数据交互
2. 数据管理：SQLite数据库存储历史数据，支持查询和分析
3. 实时监控：显示电压、电流、功率、累计用电量等实时数据
4. 设备控制：支持远程开关控制、红外学习与发射功能
5. 报警处理：实时接收并显示过载、过压等报警信息
6. 数据可视化：使用Qt Charts展示功率趋势和能耗统计图表
7. 配置管理：保存和加载连接设置、设备参数

系统采用模块化设计，便于扩展和维护，可以满足智能插座项目的所有上位机需求。

模块代码设计

由于代码量非常庞大，我将按模块分块展示关键部分的寄存器驱动代码。以下是完整的STM32F103C8T6寄存器级驱动程序：

1. 系统时钟与基本配置

// system_core.c
#include "stm32f10x.h"

// 系统时钟初始化（72MHz）
void SystemInit(void) {
    // 1. 使能HSE并等待就绪
    RCC->CR |= RCC_CR_HSEON;
    while(!(RCC->CR & RCC_CR_HSERDY));
    
    // 2. 配置FLASH预取指和等待状态
    FLASH->ACR = FLASH_ACR_PRFTBE | FLASH_ACR_LATENCY_2;
    
    // 3. 配置AHB/APB分频
    RCC->CFGR &= ~(RCC_CFGR_HPRE | RCC_CFGR_PPRE1 | RCC_CFGR_PPRE2);
    RCC->CFGR |= RCC_CFGR_PPRE1_DIV2;  // APB1 36MHz
    RCC->CFGR |= RCC_CFGR_PPRE2_DIV1;  // APB2 72MHz
    
    // 4. 配置PLL
    RCC->CFGR &= ~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLMULL);
    RCC->CFGR |= RCC_CFGR_PLLSRC_HSE;
    RCC->CFGR |= RCC_CFGR_PLLMULL9;    // 8MHz * 9 = 72MHz
    
    // 5. 使能PLL
    RCC->CR |= RCC_CR_PLLON;
    while(!(RCC->CR & RCC_CR_PLLRDY));
    
    // 6. 切换系统时钟源
    RCC->CFGR &= ~RCC_CFGR_SW;
    RCC->CFGR |= RCC_CFGR_SW_PLL;
    while((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_1);
}

// SysTick定时器初始化（1ms中断）
void SysTick_Init(void) {
    SysTick->LOAD = 72000 - 1;  // 72MHz/1000 = 72000
    SysTick->VAL = 0;
    SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | 
                   SysTick_CTRL_TICKINT_Msk | 
                   SysTick_CTRL_ENABLE_Msk;
}

// 延时函数
void delay_ms(uint32_t ms) {
    uint32_t start = SysTick->VAL;
    while(ms--) {
        while((start - SysTick->VAL) < 72000);
        start = SysTick->VAL;
    }
}

2. GPIO配置

// gpio_config.c
#include "stm32f10x.h"

typedef enum {
    // 继电器控制引脚
    RELAY_PIN = GPIO_Pin_0,     // PA0
    SSR_PIN = GPIO_Pin_1,       // PA1
    
    // 触摸按键引脚
    TOUCH_KEY1 = GPIO_Pin_4,    // PA4
    TOUCH_KEY2 = GPIO_Pin_5,    // PA5
    
    // WS2812 RGB指示灯
    WS2812_PIN = GPIO_Pin_6,    // PA6
    
    // 红外发射
    IR_TX_PIN = GPIO_Pin_7,     // PA7
    
    // 红外接收（外部中断）
    IR_RX_PIN = GPIO_Pin_0,     // PB0
    
    // HLW8032通信
    HLW8032_TX = GPIO_Pin_2,    // PA2 (USART2)
    HLW8032_RX = GPIO_Pin_3,    // PA3 (USART2)
    
    // ESP-01S WiFi
    ESP_TX = GPIO_Pin_9,        // PA9 (USART1)
    ESP_RX = GPIO_Pin_10,       // PA10 (USART1)
    
    // SYN6288语音
    SYN_TX = GPIO_Pin_2,        // PB10 (USART3)
    SYN_RX = GPIO_Pin_11,       // PB11 (USART3)
} PinDef;

void GPIO_Init(void) {
    // 使能GPIO时钟
    RCC->APB2ENR |= RCC_APB2ENR_IOPAEN | RCC_APB2ENR_IOPBEN;
    
    // 继电器控制（推挽输出）
    GPIOA->CRL &= ~(GPIO_CRL_MODE0 | GPIO_CRL_CNF0);
    GPIOA->CRL |= GPIO_CRL_MODE0_0;  // 输出模式，最大速度10MHz
    
    // SSR控制
    GPIOA->CRL &= ~(GPIO_CRL_MODE1 | GPIO_CRL_CNF1);
    GPIOA->CRL |= GPIO_CRL_MODE1_0;
    
    // 触摸按键（输入下拉）
    GPIOA->CRL &= ~(GPIO_CRL_MODE4 | GPIO_CRL_CNF4);
    GPIOA->CRL |= GPIO_CRL_CNF4_1;  // 输入下拉
    GPIOA->ODR &= ~TOUCH_KEY1;
    
    GPIOA->CRL &= ~(GPIO_CRL_MODE5 | GPIO_CRL_CNF5);
    GPIOA->CRL |= GPIO_CRL_CNF5_1;
    GPIOA->ODR &= ~TOUCH_KEY2;
    
    // WS2812（复用推挽输出）
    GPIOA->CRL &= ~(GPIO_CRL_MODE6 | GPIO_CRL_CNF6);
    GPIOA->CRL |= GPIO_CRL_MODE6_0 | GPIO_CRL_CNF6_1;
    
    // 红外发射
    GPIOA->CRL &= ~(GPIO_CRL_MODE7 | GPIO_CRL_CNF7);
    GPIOA->CRL |= GPIO_CRL_MODE7_0;
    
    // 红外接收（浮空输入）
    GPIOB->CRL &= ~(GPIO_CRL_MODE0 | GPIO_CRL_CNF0);
    GPIOB->CRL |= GPIO_CRL_CNF0_1;
}

3. HLW8032电能计量驱动

// hlw8032.c
#include "stm32f10x.h"

typedef struct {
    float voltage;      // 电压 (V)
    float current;      // 电流 (A)
    float power;        // 功率 (W)
    float energy;       // 累计电量 (kWh)
    uint8_t data[24];   // 原始数据
    uint8_t index;
} HLW8032_Data;

HLW8032_Data hlw_data = {0};

// USART2初始化（HLW8032通信）
void HLW8032_UART_Init(uint32_t baudrate) {
    // 使能USART2时钟
    RCC->APB1ENR |= RCC_APB1ENR_USART2EN;
    
    // 配置GPIO
    GPIOA->CRL &= ~(GPIO_CRL_MODE2 | GPIO_CRL_CNF2);
    GPIOA->CRL |= GPIO_CRL_MODE2_1 | GPIO_CRL_CNF2_1;  // 复用推挽输出
    
    GPIOA->CRL &= ~(GPIO_CRL_MODE3 | GPIO_CRL_CNF3);
    GPIOA->CRL |= GPIO_CRL_CNF3_0;  // 浮空输入
    
    // 波特率设置
    USART2->BRR = 72000000 / baudrate;
    
    // 使能接收中断
    USART2->CR1 |= USART_CR1_RXNEIE | USART_CR1_RE | USART_CR1_TE;
    
    // 使能USART2
    USART2->CR1 |= USART_CR1_UE;
    
    // 配置NVIC
    NVIC->ISER[1] |= (1 << (USART2_IRQn - 32));
    NVIC->IP[USART2_IRQn] = 0x03;
}

// HLW8032数据解析
void HLW8032_ParseData(void) {
    if(hlw_data.data[0] == 0x58 && hlw_data.data[1] == 0x00) {
        // 电压计算
        uint32_t volt_reg = (hlw_data.data[2] << 16) | 
                           (hlw_data.data[3] << 8) | 
                           hlw_data.data[4];
        hlw_data.voltage = (volt_reg * 1.0 / 1000.0);
        
        // 电流计算
        uint32_t curr_reg = (hlw_data.data[5] << 16) | 
                           (hlw_data.data[6] << 8) | 
                           hlw_data.data[7];
        hlw_data.current = (curr_reg * 1.0 / 1000.0);
        
        // 功率计算
        uint32_t power_reg = (hlw_data.data[8] << 16) | 
                            (hlw_data.data[9] << 8) | 
                            hlw_data.data[10];
        hlw_data.power = (power_reg * 1.0 / 1000.0);
        
        // 累计电量（需要自己累计）
        static float total_energy = 0;
        total_energy += hlw_data.power / 3600000.0;  // 累加瓦时
        hlw_data.energy = total_energy;
    }
}

// USART2中断服务函数
void USART2_IRQHandler(void) {
    if(USART2->SR & USART_SR_RXNE) {
        uint8_t ch = USART2->DR;
        
        // HLW8032数据帧格式：0x58 0x00 + 24字节数据
        if(hlw_data.index == 0 && ch == 0x58) {
            hlw_data.data[hlw_data.index++] = ch;
        } else if(hlw_data.index == 1 && ch == 0x00) {
            hlw_data.data[hlw_data.index++] = ch;
        } else if(hlw_data.index > 1 && hlw_data.index < 24) {
            hlw_data.data[hlw_data.index++] = ch;
            if(hlw_data.index == 24) {
                HLW8032_ParseData();
                hlw_data.index = 0;
            }
        } else {
            hlw_data.index = 0;
        }
    }
}

// 获取电气参数
void HLW8032_GetParams(float *volt, float *curr, float *power, float *energy) {
    *volt = hlw_data.voltage;
    *curr = hlw_data.current;
    *power = hlw_data.power;
    *energy = hlw_data.energy;
}

4. WS2812 RGB指示灯驱动

// ws2812.c
#include "stm32f10x.h"

#define WS2812_NUM  3
#define RESET_PULSE 50  // 复位脉冲时间(us)

uint8_t ws2812_buffer[WS2812_NUM * 24];  // 每个LED 24bit

// WS2812时序控制（定时器2 PWM输出）
void WS2812_Init(void) {
    // 使能TIM2时钟
    RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;
    
    // 配置TIM2 PWM输出
    TIM2->CR1 = 0;
    TIM2->CR2 = 0;
    TIM2->PSC = 71;  // 72MHz/72 = 1MHz
    TIM2->ARR = 29;  // 30个计数周期 = 30us
    
    // 配置通道1为PWM模式
    TIM2->CCMR1 |= TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2;  // PWM模式1
    TIM2->CCMR1 |= TIM_CCMR1_OC1PE;  // 预装载使能
    TIM2->CCER |= TIM_CCER_CC1E;     // 输出使能
    
    // 使能TIM2
    TIM2->CR1 |= TIM_CR1_CEN;
}

// 发送一个字节到WS2812
void WS2812_SendByte(uint8_t data) {
    for(uint8_t i = 0; i < 8; i++) {
        if(data & (1 << (7 - i))) {
            // 发送'1' (高电平0.8us + 低电平0.45us)
            TIM2->CCR1 = 9;  // 高电平9个周期
            delay_us(1);
            TIM2->CCR1 = 6;  // 低电平6个周期
            delay_us(1);
        } else {
            // 发送'0' (高电平0.4us + 低电平0.85us)
            TIM2->CCR1 = 4;  // 高电平4个周期
            delay_us(1);
            TIM2->CCR1 = 11; // 低电平11个周期
            delay_us(1);
        }
    }
}

// 设置单个LED颜色
void WS2812_SetLED(uint8_t index, uint8_t r, uint8_t g, uint8_t b) {
    if(index >= WS2812_NUM) return;
    
    uint8_t *ptr = &ws2812_buffer[index * 24];
    
    // WS2812顺序：GRB
    for(int i = 0; i < 8; i++) ptr[i] = (g >> (7 - i)) & 0x01;
    for(int i = 0; i < 8; i++) ptr[i + 8] = (r >> (7 - i)) & 0x01;
    for(int i = 0; i < 8; i++) ptr[i + 16] = (b >> (7 - i)) & 0x01;
}

// 更新所有LED
void WS2812_Update(void) {
    __disable_irq();
    
    // 发送所有数据
    for(uint16_t i = 0; i < WS2812_NUM * 24; i++) {
        if(ws2812_buffer[i]) {
            TIM2->CCR1 = 9;
            delay_us(1);
            TIM2->CCR1 = 6;
            delay_us(1);
        } else {
            TIM2->CCR1 = 4;
            delay_us(1);
            TIM2->CCR1 = 11;
            delay_us(1);
        }
    }
    
    // 复位脉冲
    TIM2->CCR1 = 0;
    delay_us(RESET_PULSE);
    
    __enable_irq();
}

// 指示灯状态
void LED_SetStatus(uint8_t status) {
    switch(status) {
        case 0:  // 正常（绿色）
            WS2812_SetLED(0, 0, 255, 0);
            WS2812_SetLED(1, 0, 255, 0);
            WS2812_SetLED(2, 0, 255, 0);
            break;
        case 1:  // 过载报警（红色闪烁）
            WS2812_SetLED(0, 255, 0, 0);
            WS2812_SetLED(1, 0, 0, 0);
            WS2812_SetLED(2, 255, 0, 0);
            break;
        case 2:  // WiFi连接中（蓝色呼吸）
            WS2812_SetLED(0, 0, 0, 100);
            WS2812_SetLED(1, 0, 0, 150);
            WS2812_SetLED(2, 0, 0, 100);
            break;
    }
    WS2812_Update();
}

5. 红外学习与发射

// infrared.c
#include "stm32f10x.h"

#define IR_MAX_PULSES 512
#define IR_TIMEOUT    20000  // 20ms超时

typedef struct {
    uint16_t pulses[IR_MAX_PULSES];
    uint16_t count;
    uint8_t learned;
} IR_Data;

IR_Data ir_data = {0};

// 红外接收初始化（外部中断）
void IR_RX_Init(void) {
    // 使能AFIO时钟
    RCC->APB2ENR |= RCC_APB2ENR_AFIOEN;
    
    // 配置PB0为外部中断
    AFIO->EXTICR[0] &= ~AFIO_EXTICR1_EXTI0;
    AFIO->EXTICR[0] |= AFIO_EXTICR1_EXTI0_PB;
    
    // 配置下降沿触发
    EXTI->FTSR |= EXTI_FTSR_TR0;
    
    // 使能中断
    EXTI->IMR |= EXTI_IMR_MR0;
    
    // 配置NVIC
    NVIC->ISER[0] |= (1 << EXTI0_IRQn);
    NVIC->IP[EXTI0_IRQn] = 0x03;
}

// 红外发射初始化（定时器3 PWM）
void IR_TX_Init(void) {
    // 使能TIM3时钟
    RCC->APB1ENR |= RCC_APB1ENR_TIM3EN;
    
    // 配置TIM3 PWM输出
    TIM3->CR1 = 0;
    TIM3->PSC = 71;  // 72MHz/72 = 1MHz
    TIM3->ARR = 26;  // 38kHz载波
    
    // 配置通道2
    TIM3->CCMR1 |= TIM_CCMR1_OC2M_1 | TIM_CCMR1_OC2M_2;
    TIM3->CCMR1 |= TIM_CCMR1_OC2PE;
    TIM3->CCER |= TIM_CCER_CC2E;
}

// 发送红外信号
void IR_SendSignal(void) {
    if(!ir_data.learned || ir_data.count == 0) return;
    
    // 38kHz载波
    TIM3->CCR2 = 13;  // 50%占空比
    
    for(uint16_t i = 0; i < ir_data.count; i++) {
        if(i % 2 == 0) {
            // 高电平时间段
            TIM3->CR1 |= TIM_CR1_CEN;
            delay_us(ir_data.pulses[i]);
            TIM3->CR1 &= ~TIM_CR1_CEN;
        } else {
            // 低电平时间段
            delay_us(ir_data.pulses[i]);
        }
    }
}

// 红外学习模式
void IR_LearnMode(void) {
    ir_data.count = 0;
    ir_data.learned = 0;
    
    // 等待红外信号
    uint32_t start_time = SysTick->VAL;
    uint32_t last_time = start_time;
    uint8_t last_state = (GPIOB->IDR & IR_RX_PIN) ? 1 : 0;
    
    while(1) {
        uint8_t current_state = (GPIOB->IDR & IR_RX_PIN) ? 1 : 0;
        uint32_t current_time = SysTick->VAL;
        
        if(current_state != last_state) {
            uint32_t pulse_width = (last_time > current_time) ? 
                                  (last_time - current_time) / 72 : 
                                  (0xFFFFFF - current_time + last_time) / 72;
            
            if(pulse_width > IR_TIMEOUT) {
                // 超时，结束学习
                break;
            }
            
            if(ir_data.count < IR_MAX_PULSES) {
                ir_data.pulses[ir_data.count++] = pulse_width;
            }
            
            last_state = current_state;
            last_time = current_time;
        }
        
        // 检查学习完成
        if(ir_data.count >= 4 && (current_time - start_time) > 2000000) {
            break;
        }
    }
    
    if(ir_data.count > 10) {
        ir_data.learned = 1;
    }
}

// 外部中断0服务函数
void EXTI0_IRQHandler(void) {
    if(EXTI->PR & EXTI_PR_PR0) {
        // 清除中断标志
        EXTI->PR = EXTI_PR_PR0;
        
        static uint32_t last_time = 0;
        uint32_t current_time = SysTick->VAL;
        uint32_t pulse_width = (last_time > current_time) ? 
                              (last_time - current_time) / 72 : 
                              (0xFFFFFF - current_time + last_time) / 72;
        
        if(pulse_width < IR_TIMEOUT) {
            if(ir_data.count < IR_MAX_PULSES) {
                ir_data.pulses[ir_data.count++] = pulse_width;
            }
        }
        
        last_time = current_time;
    }
}

6. SYN6288语音合成驱动

// syn6288.c
#include "stm32f10x.h"

// USART3初始化
void SYN6288_UART_Init(uint32_t baudrate) {
    // 使能USART3时钟
    RCC->APB1ENR |= RCC_APB1ENR_USART3EN;
    
    // 配置GPIO
    GPIOB->CRH &= ~(GPIO_CRH_MODE10 | GPIO_CRH_CNF10);
    GPIOB->CRH |= GPIO_CRH_MODE10_1 | GPIO_CRH_CNF10_1;  // 复用推挽输出
    
    GPIOB->CRH &= ~(GPIO_CRH_MODE11 | GPIO_CRH_CNF11);
    GPIOB->CRH |= GPIO_CRH_CNF11_0;  // 浮空输入
    
    // 波特率设置
    USART3->BRR = 36000000 / baudrate;  // APB1 36MHz
    
    // 配置USART3
    USART3->CR1 |= USART_CR1_RE | USART_CR1_TE;
    USART3->CR1 |= USART_CR1_UE;
}

// 发送语音命令
void SYN6288_Speak(const char *text) {
    uint8_t frame[256];
    uint8_t len = strlen(text);
    uint8_t checksum = 0;
    
    // 帧头
    frame[0] = 0xFD;
    
    // 数据长度 = 文本长度 + 3
    frame[1] = len + 3;
    
    // 命令字
    frame[2] = 0x01;
    
    // 文本数据
    for(uint8_t i = 0; i < len; i++) {
        frame[3 + i] = text[i];
        checksum ^= text[i];
    }
    
    // 异或校验
    frame[3 + len] = checksum;
    
    // 发送数据
    for(uint8_t i = 0; i < len + 4; i++) {
        while(!(USART3->SR & USART_SR_TXE));
        USART3->DR = frame[i];
    }
}

// 报警语音
void Voice_Alert(uint8_t type) {
    switch(type) {
        case 1:  // 过载报警
            SYN6288_Speak("警告！插座过载，请立即断开负载");
            break;
        case 2:  // 过压报警
            SYN6288_Speak("警告！电压过高，请检查电源");
            break;
        case 3:  // WiFi连接成功
            SYN6288_Speak("网络连接成功");
            break;
        case 4:  // 设备开关
            SYN6288_Speak("设备已打开");
            break;
    }
}

7. ESP-01S WiFi通信

// wifi_esp01s.c
#include "stm32f10x.h"

#define WIFI_BUFFER_SIZE 512

typedef enum {
    WIFI_IDLE,
    WIFI_CONNECTING,
    WIFI_CONNECTED,
    WIFI_ERROR
} WiFi_State;

WiFi_State wifi_state = WIFI_IDLE;
char wifi_buffer[WIFI_BUFFER_SIZE];
uint16_t wifi_index = 0;

// USART1初始化（ESP-01S通信）
void ESP01S_UART_Init(uint32_t baudrate) {
    // 使能USART1时钟
    RCC->APB2ENR |= RCC_APB2ENR_USART1EN;
    
    // 配置GPIO
    GPIOA->CRH &= ~(GPIO_CRH_MODE9 | GPIO_CRH_CNF9);
    GPIOA->CRH |= GPIO_CRH_MODE9_1 | GPIO_CRH_CNF9_1;  // 复用推挽输出
    
    GPIOA->CRH &= ~(GPIO_CRH_MODE10 | GPIO_CRH_CNF10);
    GPIOA->CRH |= GPIO_CRH_CNF10_0;  // 浮空输入
    
    // 波特率设置
    USART1->BRR = 72000000 / baudrate;
    
    // 使能接收中断
    USART1->CR1 |= USART_CR1_RXNEIE | USART_CR1_RE | USART_CR1_TE;
    USART1->CR1 |= USART_CR1_UE;
    
    // 配置NVIC
    NVIC->ISER[1] |= (1 << (USART1_IRQn - 32));
    NVIC->IP[USART1_IRQn] = 0x03;
}

// 发送AT命令
void ESP_SendCommand(const char *cmd) {
    while(*cmd) {
        while(!(USART1->SR & USART_SR_TXE));
        USART1->DR = *cmd++;
    }
    while(!(USART1->SR & USART_SR_TXE));
    USART1->DR = '\r';
    while(!(USART1->SR & USART_SR_TXE));
    USART1->DR = '\n';
}

// WiFi初始化连接
void WiFi_InitConnection(const char *ssid, const char *password) {
    wifi_state = WIFI_CONNECTING;
    LED_SetStatus(2);  // 蓝色呼吸灯
    
    // 发送AT命令序列
    delay_ms(1000);
    ESP_SendCommand("AT");  // 测试AT指令
    delay_ms(1000);
    
    ESP_SendCommand("AT+CWMODE=1");  // Station模式
    delay_ms(1000);
    
    // 连接WiFi
    char cmd[128];
    sprintf(cmd, "AT+CWJAP=\"%s\",\"%s\"", ssid, password);
    ESP_SendCommand(cmd);
    delay_ms(5000);
    
    // 启用多连接
    ESP_SendCommand("AT+CIPMUX=1");
    delay_ms(1000);
    
    // 建立TCP连接（假设服务器IP:192.168.1.100，端口:8080）
    ESP_SendCommand("AT+CIPSTART=0,\"TCP\",\"192.168.1.100\",8080");
    delay_ms(3000);
    
    wifi_state = WIFI_CONNECTED;
    LED_SetStatus(0);  // 绿色常亮
    Voice_Alert(3);    // 网络连接成功语音
}

// 发送数据到云端
void WiFi_SendData(float volt, float curr, float power, float energy) {
    if(wifi_state != WIFI_CONNECTED) return;
    
    char data[256];
    sprintf(data, "{\"volt\":%.2f,\"curr\":%.2f,\"power\":%.2f,\"energy\":%.3f}", 
            volt, curr, power, energy);
    
    char cmd[64];
    sprintf(cmd, "AT+CIPSEND=0,%d", strlen(data));
    
    ESP_SendCommand(cmd);
    delay_ms(100);
    ESP_SendCommand(data);
}

// USART1中断服务函数
void USART1_IRQHandler(void) {
    if(USART1->SR & USART_SR_RXNE) {
        char ch = USART1->DR;
        
        if(wifi_index < WIFI_BUFFER_SIZE - 1) {
            wifi_buffer[wifi_index++] = ch;
            wifi_buffer[wifi_index] = '\0';
            
            // 检查响应
            if(strstr(wifi_buffer, "OK")) {
                // AT命令成功
                wifi_index = 0;
            } else if(strstr(wifi_buffer, "ERROR")) {
                wifi_state = WIFI_ERROR;
                wifi_index = 0;
            } else if(strstr(wifi_buffer, "+IPD")) {
                // 收到服务器数据
                // 解析JSON指令...
                wifi_index = 0;
            }
        } else {
            wifi_index = 0;
        }
    }
}