项目开发背景

随着科技的飞速发展和人们生活水平的提高，智能家居系统逐渐成为现代家庭的重要组成部分。智能灯光控制作为智能家居的核心功能之一，不仅能够提升居住舒适度，还能有效节约能源，满足用户对便捷、智能化生活的追求。传统的灯光控制系统多依赖于有线连接或简单的遥控器，存在布线复杂、灵活性差、无法远程控制等局限性，用户往往需要手动操作开关，无法根据环境变化自动调节，也无法实现多房间的统一管理。

为了克服这些不足，无线通信技术如Zigbee被引入智能家居领域。Zigbee技术以其低功耗、低成本、高可靠性和自组网能力，成为构建智能灯光控制系统的理想选择。它能够轻松组建包含协调器、路由器和终端设备的网络，实现设备间的稳定通信和广泛覆盖，从而支持灵活的远程控制和自动化管理。

本项目的开发旨在利用Zigbee技术构建一个高效的智能家居灯光控制系统，通过集成STM32单片机、Zigbee模块、光敏电阻和继电器等硬件，实现环境光照监测、灯具开关控制、手机APP远程操作以及多种场景模式功能。这不仅解决了传统系统在灵活性和智能化方面的缺陷，还为推动智能家居的普及和能源节约提供了实用解决方案，具有重要的社会和经济价值。

设计实现的功能

(1) 组建Zigbee无线网络，包含协调器、路由器和终端设备。
(2) 终端设备节点能监测环境光照强度，并控制灯具开关。
(3) 用户可通过手机APP（通过协调器）远程控制任意房间的灯光。
(4) 系统支持场景模式，如“全开”、“全关”、“夜间模式”。

项目硬件模块组成

(1) 主控与组网：STM32单片机 + Zigbee模块（如CC2530）。
(2) 传感模块：光敏电阻模块。
(3) 执行模块：继电器模块。
(4) 协调器：Zigbee-USB协调器，用于连接上位机或网关。

设计意义

该设计基于Zigbee无线网络技术构建智能家居灯光控制系统，能够实现稳定可靠的设备组网，支持协调器、路由器和终端设备的协同工作，有效降低系统部署成本和维护复杂性，同时利用Zigbee的低功耗特性延长设备使用寿命，为家庭环境提供高效的无线通信基础。

通过集成光敏电阻模块，系统能够实时监测环境光照强度，并结合继电器模块自动控制灯具开关，实现智能调光与节能管理，这不仅提升了能源利用效率，还增强了居住舒适度，满足用户对自动化照明的基本需求。

系统支持用户通过手机APP远程控制任意房间的灯光，借助Zigbee-USB协调器连接上位机或网关，实现了灵活便捷的远程操作，大大提高了用户的生活便利性，尤其适用于外出或移动场景下的家庭照明管理。

此外，系统内置多种场景模式如“全开”、“全关”和“夜间模式”，允许用户一键切换照明状态，简化了日常操作流程，增强了系统的实用性和智能化水平，为现代家庭提供了一种高效且易用的灯光控制解决方案。

设计思路

设计思路首先围绕Zigbee无线网络的组建展开，系统采用协调器作为网络核心，负责初始化和管理整个网络，路由器用于扩展网络覆盖范围并转发数据，终端设备则部署在各个房间中，通过Zigbee模块与协调器通信，确保网络稳定可靠。硬件上，协调器使用Zigbee-USB协调器连接上位机或网关，而终端设备以STM32单片机为主控，搭配Zigbee模块实现无线通信。

在终端设备层面，每个节点集成光敏电阻模块来实时监测环境光照强度，并将数据通过Zigbee网络传输至协调器；同时，STM32单片机根据光照数据或控制指令驱动继电器模块，实现灯具的开关控制，确保系统能自动响应环境变化。这种设计使得终端设备既能独立工作，又能融入网络协同。

用户远程控制功能通过手机APP实现，APP与协调器连接，协调器作为网关接收APP指令并将其转发至指定的终端设备节点，从而允许用户远程控制任意房间的灯光开关。系统通过协调器解析指令并路由到对应设备，确保控制实时性和准确性。

场景模式功能基于协调器的逻辑处理实现，系统预设“全开”、“全关”和“夜间模式”等场景，协调器在接收到模式指令后，统一向所有相关终端设备发送批量控制命令，例如在“夜间模式”下自动调整灯光状态，提升用户体验和能源效率。整个系统设计注重实际应用，确保功能稳定且易于维护。

框架图

+-------------------+       +-------------------+
|   手机APP         |       |   协调器          |
|   (用户控制)      |<----->|   (Zigbee-USB)    |
|   - 场景模式      |       |   - 网络管理      |
|   (全开/全关/夜间)|       +-------------------+
+-------------------+               |
                                    | Zigbee 无线协议
                                    |
          +-------------------------+-------------------------+
          |                         |                         |
    +-------------+           +-------------+           +-------------+
    |  路由器     |           |  终端设备1  |           |  终端设备2  |
    | (可选中继)  |           | (房间1)     |           | (房间2)     |
    +-------------+           +-------------+           +-------------+
          |                         |                         |
          |                   +-----------+             +-----------+
          |                   |STM32+Zigbee|            |STM32+Zigbee|
          |                   |光敏传感器  |            |光敏传感器  |
          |                   |继电器      |            |继电器      |
          |                   +-----------+             +-----------+
          |                         |                         |
          |                   +-----------+             +-----------+
          |                   |   灯具    |             |   灯具    |
          |                   +-----------+             +-----------+
          |                         |                         |
    +-------------+           +-------------+           +-------------+
    |  ...更多设备|           |  ...更多设备|           |  ...更多设备|
    +-------------+           +-------------+           +-------------+

系统总体设计

该系统总体设计基于Zigbee无线通信技术，构建一个智能家居灯光控制系统，实现灯光的远程控制和自动化管理。系统采用分布式架构，通过Zigbee网络连接各个设备节点，确保稳定可靠的数据传输和指令执行。

Zigbee网络由协调器、路由器和终端设备组成，其中协调器作为网络中心，负责初始化网络并管理设备入网，路由器扩展网络覆盖范围，增强信号中继能力，终端设备则作为网络中的叶节点，执行具体的传感和控制任务。这种分层结构提高了系统的可扩展性和鲁棒性，适用于多房间家居环境。

终端设备节点集成了光敏电阻模块，用于实时监测环境光照强度，并将数据通过Zigbee网络上报。同时，这些节点通过继电器模块控制灯具的开关状态，实现基于环境光的自动调节或用户指令的响应。每个终端设备可独立工作，也可通过网络协同操作。

用户交互通过手机APP实现，APP通过协调器与Zigbee网络通信，协调器通常以Zigbee-USB形式连接至上位机或网关，作为无线网络与外部设备的接口。用户可通过APP远程控制任意房间的灯光，查看当前状态，并发送开关指令，确保便捷的远程管理。

系统支持预设场景模式，如“全开”模式可一次性打开所有灯光，“全关”模式关闭所有灯光，“夜间模式”则根据光照阈值自动调整灯光状态，以优化能源使用和居住舒适度。这些模式通过协调器统一调度，终端设备协同执行，实现智能化的场景切换。

硬件模块以STM32单片机作为主控制器，处理数据逻辑和通信协议，结合Zigbee模块如CC2530实现无线组网。光敏电阻模块负责环境光传感，继电器模块驱动灯具开关，Zigbee-USB协调器确保网络与外部系统的连接，整个硬件设计注重低功耗和实时性，满足家居应用需求。

系统功能总结

设计的各个功能模块描述

Zigbee通信模块负责组建无线网络，采用STM32单片机作为主控芯片，搭配Zigbee模块如CC2530实现网络功能。该模块包括协调器、路由器和终端设备，协调器负责网络初始化和数据转发，路由器扩展网络覆盖范围，终端设备连接传感器和执行器，确保网络稳定通信。

环境监测模块集成光敏电阻模块于终端设备节点，用于实时检测环境光照强度。该模块将采集的光照数据通过Zigbee网络传输至协调器或相关控制单元，为自动灯光控制提供依据。

灯光控制模块通过继电器模块实现对灯具的开关操作，继电器由STM32单片机驱动，根据接收到的控制指令或传感器数据执行相应动作，确保灯光状态可精确调整。

远程控制模块允许用户通过手机APP发送指令，指令经由互联网传输至Zigbee-USB协调器，协调器将命令解析后通过Zigbee网络转发至目标终端设备，实现任意房间灯光的远程监控和管理。

场景模式模块支持预设场景如“全开”、“全关”和“夜间模式”，用户可通过手机APP触发场景命令，系统自动协调所有终端设备执行相应操作，例如在夜间模式下根据光照强度自动调节灯光状态。

上位机代码设计

#include <QApplication>
#include <QMainWindow>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QPushButton>
#include <QLabel>
#include <QComboBox>
#include <QSerialPort>
#include <QSerialPortInfo>
#include <QMessageBox>
#include <QTimer>
#include <QGroupBox>
#include <QTextEdit>
#include <QSpinBox>
#include <QCheckBox>
#include <QProgressBar>

class ZigbeeController : public QMainWindow
{
    Q_OBJECT

public:
    ZigbeeController(QWidget *parent = nullptr) : QMainWindow(parent)
    {
        setupUI();
        setupSerialPort();
        setupConnections();
    }

    ~ZigbeeController()
    {
        if (serialPort && serialPort->isOpen()) {
            serialPort->close();
        }
    }

private slots:
    void connectToCoordinator()
    {
        if (serialPort) {
            serialPort->setPortName(portComboBox->currentText());
            serialPort->setBaudRate(QSerialPort::Baud9600);
            serialPort->setDataBits(QSerialPort::Data8);
            serialPort->setParity(QSerialPort::NoParity);
            serialPort->setStopBits(QSerialPort::OneStop);
            serialPort->setFlowControl(QSerialPort::NoFlowControl);

            if (serialPort->open(QIODevice::ReadWrite)) {
                statusLabel->setText("已连接到协调器");
                connectionStatus->setValue(100);
                refreshPorts();
            } else {
                QMessageBox::critical(this, "连接错误", "无法连接到协调器");
            }
        }
    }

    void refreshPorts()
    {
        portComboBox->clear();
        QList<QSerialPortInfo> ports = QSerialPortInfo::availablePorts();
        for (const QSerialPortInfo &port : ports) {
            portComboBox->addItem(port.portName());
        }
    }

    void readData()
    {
        if (serialPort && serialPort->isOpen()) {
            QByteArray data = serialPort->readAll();
            if (!data.isEmpty()) {
                QString message = QString::fromUtf8(data);
                logTextEdit->append("接收: " + message);
                processReceivedData(message);
            }
        }
    }

    void sendControlCommand(const QString &command)
    {
        if (serialPort && serialPort->isOpen()) {
            QByteArray data = command.toUtf8() + "\n";
            serialPort->write(data);
            logTextEdit->append("发送: " + command);
        } else {
            QMessageBox::warning(this, "警告", "未连接到协调器");
        }
    }

    void controlRoomLight()
    {
        QString room = roomComboBox->currentText();
        QString command = room + "_" + (lightOnCheckBox->isChecked() ? "ON" : "OFF");
        sendControlCommand(command);
    }

    void setBrightness()
    {
        QString room = roomComboBox->currentText();
        int brightness = brightnessSpinBox->value();
        QString command = room + "_BRIGHTNESS_" + QString::number(brightness);
        sendControlCommand(command);
    }

    void activateScene()
    {
        QString scene = sceneComboBox->currentText();
        QString command = "SCENE_" + scene;
        sendControlCommand(command);
    }

    void queryNodeStatus()
    {
        sendControlCommand("QUERY_ALL_STATUS");
    }

private:
    void setupUI()
    {
        setWindowTitle("基于Zigbee的智能家居灯光控制系统");
        setMinimumSize(800, 600);

        QWidget *centralWidget = new QWidget(this);
        setCentralWidget(centralWidget);

        QVBoxLayout *mainLayout = new QVBoxLayout(centralWidget);

        // 连接设置
        QGroupBox *connectionGroup = new QGroupBox("协调器连接设置");
        QHBoxLayout *connectionLayout = new QHBoxLayout(connectionGroup);
        
        portComboBox = new QComboBox();
        refreshButton = new QPushButton("刷新端口");
        connectButton = new QPushButton("连接协调器");
        statusLabel = new QLabel("未连接");
        connectionStatus = new QProgressBar();
        connectionStatus->setRange(0, 100);
        connectionStatus->setValue(0);

        connectionLayout->addWidget(new QLabel("串口:"));
        connectionLayout->addWidget(portComboBox);
        connectionLayout->addWidget(refreshButton);
        connectionLayout->addWidget(connectButton);
        connectionLayout->addWidget(statusLabel);
        connectionLayout->addWidget(connectionStatus);

        // 房间灯光控制
        QGroupBox *lightControlGroup = new QGroupBox("房间灯光控制");
        QGridLayout *lightLayout = new QGridLayout(lightControlGroup);
        
        roomComboBox = new QComboBox();
        roomComboBox->addItems({"客厅", "卧室", "厨房", "书房", "卫生间"});
        
        lightOnCheckBox = new QCheckBox("开灯");
        brightnessSpinBox = new QSpinBox();
        brightnessSpinBox->setRange(0, 100);
        brightnessSpinBox->setValue(50);
        
        QPushButton *applyLightBtn = new QPushButton("应用设置");
        QPushButton *queryStatusBtn = new QPushButton("查询状态");

        lightLayout->addWidget(new QLabel("房间:"), 0, 0);
        lightLayout->addWidget(roomComboBox, 0, 1);
        lightLayout->addWidget(lightOnCheckBox, 1, 0);
        lightLayout->addWidget(new QLabel("亮度:"), 1, 1);
        lightLayout->addWidget(brightnessSpinBox, 1, 2);
        lightLayout->addWidget(applyLightBtn, 2, 0);
        lightLayout->addWidget(queryStatusBtn, 2, 1);

        // 场景模式
        QGroupBox *sceneGroup = new QGroupBox("场景模式");
        QHBoxLayout *sceneLayout = new QHBoxLayout(sceneGroup);
        
        sceneComboBox = new QComboBox();
        sceneComboBox->addItems({"全开", "全关", "夜间模式", "会客模式", "影院模式"});
        
        QPushButton *activateSceneBtn = new QPushButton("激活场景");

        sceneLayout->addWidget(new QLabel("场景:"));
        sceneLayout->addWidget(sceneComboBox);
        sceneLayout->addWidget(activateSceneBtn);

        // 系统日志
        QGroupBox *logGroup = new QGroupBox("系统日志");
        QVBoxLayout *logLayout = new QVBoxLayout(logGroup);
        
        logTextEdit = new QTextEdit();
        logTextEdit->setReadOnly(true);
        
        QPushButton *clearLogBtn = new QPushButton("清空日志");

        logLayout->addWidget(logTextEdit);
        logLayout->addWidget(clearLogBtn);

        // 添加到主布局
        mainLayout->addWidget(connectionGroup);
        mainLayout->addWidget(lightControlGroup);
        mainLayout->addWidget(sceneGroup);
        mainLayout->addWidget(logGroup);

        // 连接信号槽
        connect(refreshButton, &QPushButton::clicked, this, &ZigbeeController::refreshPorts);
        connect(connectButton, &QPushButton::clicked, this, &ZigbeeController::connectToCoordinator);
        connect(applyLightBtn, &QPushButton::clicked, this, &ZigbeeController::controlRoomLight);
        connect(applyLightBtn, &QPushButton::clicked, this, &ZigbeeController::setBrightness);
        connect(queryStatusBtn, &QPushButton::clicked, this, &ZigbeeController::queryNodeStatus);
        connect(activateSceneBtn, &QPushButton::clicked, this, &ZigbeeController::activateScene);
        connect(clearLogBtn, &QPushButton::clicked, logTextEdit, &QTextEdit::clear);

        refreshPorts();
    }

    void setupSerialPort()
    {
        serialPort = new QSerialPort(this);
        connect(serialPort, &QSerialPort::readyRead, this, &ZigbeeController::readData);
    }

    void setupConnections()
    {
        // 定时查询节点状态
        QTimer *statusTimer = new QTimer(this);
        connect(statusTimer, &QTimer::timeout, this, &ZigbeeController::queryNodeStatus);
        statusTimer->start(10000); // 每10秒查询一次
    }

    void processReceivedData(const QString &data)
    {
        // 解析接收到的数据
        if (data.contains("LIGHT_INTENSITY")) {
            // 处理光照强度数据
            QStringList parts = data.split(":");
            if (parts.size() >= 2) {
                QString room = parts[0];
                QString intensity = parts[1];
                logTextEdit->append(room + " 光照强度: " + intensity);
            }
        } else if (data.contains("STATUS")) {
            // 处理设备状态
            logTextEdit->append("设备状态更新: " + data);
        }
    }

    // UI组件
    QComboBox *portComboBox;
    QComboBox *roomComboBox;
    QComboBox *sceneComboBox;
    QPushButton *refreshButton;
    QPushButton *connectButton;
    QCheckBox *lightOnCheckBox;
    QSpinBox *brightnessSpinBox;
    QLabel *statusLabel;
    QProgressBar *connectionStatus;
    QTextEdit *logTextEdit;

    // 串口通信
    QSerialPort *serialPort;
};

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

#include "main.moc"

# CMakeLists.txt
cmake_minimum_required(VERSION 3.16)
project(ZigbeeLightControl)

set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(Qt6 REQUIRED COMPONENTS Core Widgets SerialPort)

qt_standard_project_setup()

qt_add_executable(ZigbeeLightControl
    main.cpp
)

qt_add_resources(ZigbeeLightControl "resources"
    PREFIX "/"
    FILES
        icons/connect.png
        icons/disconnect.png
        icons/light_on.png
        icons/light_off.png
)

target_link_libraries(ZigbeeLightControl Qt6::Core Qt6::Widgets Qt6::SerialPort)

<!-- ZigbeeLightControl.pro -->
QT += core widgets serialport

CONFIG += c++17

SOURCES += \
    main.cpp

HEADERS +=

RESOURCES += \
    resources.qrc

这个完整的Zigbee智能家居灯光控制系统上位机代码包含以下主要功能：

1. 协调器连接管理：

   • 自动检测可用串口
   • 连接/断开Zigbee协调器
   • 连接状态显示

2. 房间灯光控制：

   • 选择不同房间
   • 控制灯光开关
   • 调节亮度等级
   • 实时状态查询

3. 场景模式控制：

   • 全开模式
   • 全关模式
   • 夜间模式
   • 会客模式
   • 影院模式

4. 系统监控：

   • 实时通信日志
   • 节点状态监控
   • 光照强度显示

5. 通信协议：

   • 基于串口的命令通信
   • 支持节点状态查询
   • 场景模式控制命令

代码采用模块化设计，易于扩展和维护，支持跨平台运行。

模块代码设计

#include "stm32f10x.h"

// 引脚定义
#define LIGHT_SENSOR_PIN GPIO_Pin_0  // PA0 - 光敏电阻
#define RELAY_PIN GPIO_Pin_13        // PC13 - 继电器控制
#define ZIGBEE_TX_PIN GPIO_Pin_9     // PA9 - Zigbee TX
#define ZIGBEE_RX_PIN GPIO_Pin_10    // PA10 - Zigbee RX

// ADC通道
#define LIGHT_SENSOR_ADC_CHANNEL ADC_Channel_0

// 系统变量
volatile uint16_t light_level = 0;
volatile uint8_t light_status = 0;
volatile uint8_t auto_mode = 1;

// 函数声明
void RCC_Configuration(void);
void GPIO_Configuration(void);
void ADC_Configuration(void);
void USART_Configuration(void);
void NVIC_Configuration(void);
uint16_t Read_ADC(uint8_t channel);
void Delay_ms(uint32_t nTime);
void Send_To_Zigbee(uint8_t* data, uint8_t len);
void Process_Zigbee_Command(uint8_t* cmd);

// 系统时钟配置
void RCC_Configuration(void)
{
    // 开启外设时钟
    RCC->APB2ENR |= RCC_APB2ENR_IOPAEN | RCC_APB2ENR_IOPCEN | 
                    RCC_APB2ENR_AFIOEN | RCC_APB2ENR_ADC1EN | 
                    RCC_APB2ENR_USART1EN;
    
    // ADC时钟配置
    RCC->CFGR &= ~RCC_CFGR_ADCPRE;
    RCC->CFGR |= RCC_CFGR_ADCPRE_DIV6;
}

// GPIO配置
void GPIO_Configuration(void)
{
    // PA0 - 光敏电阻(模拟输入)
    GPIOA->CRL &= ~(GPIO_CRL_MODE0 | GPIO_CRL_CNF0);
    GPIOA->CRL |= GPIO_CRL_CNF0_1;  // 模拟输入模式
    
    // PC13 - 继电器控制(推挽输出)
    GPIOC->CRH &= ~(GPIO_CRH_MODE13 | GPIO_CRH_CNF13);
    GPIOC->CRH |= GPIO_CRH_MODE13_1; // 输出模式，最大速度2MHz
    
    // PA9 - USART1 TX (推挽复用输出)
    GPIOA->CRH &= ~(GPIO_CRH_MODE9 | GPIO_CRH_CNF9);
    GPIOA->CRH |= GPIO_CRH_MODE9_1 | GPIO_CRH_CNF9_1;
    
    // PA10 - USART1 RX (浮空输入)
    GPIOA->CRH &= ~(GPIO_CRH_MODE10 | GPIO_CRH_CNF10);
    GPIOA->CRH |= GPIO_CRH_CNF10_0;
}

// ADC配置
void ADC_Configuration(void)
{
    // 复位ADC1
    ADC1->CR2 = 0;
    
    // 配置ADC1
    ADC1->CR1 = 0;
    ADC1->CR2 = ADC_CR2_ADON | ADC_CR2_EXTSEL | ADC_CR2_EXTTRIG;
    
    // 采样时间配置
    ADC1->SMPR2 &= ~ADC_SMPR2_SMP0;
    ADC1->SMPR2 |= ADC_SMPR2_SMP0_2 | ADC_SMPR2_SMP0_1; // 239.5周期
    
    // 规则序列配置
    ADC1->SQR1 = 0;
    ADC1->SQR2 = 0;
    ADC1->SQR3 = LIGHT_SENSOR_ADC_CHANNEL;
    
    // 校准ADC
    ADC1->CR2 |= ADC_CR2_RSTCAL;
    while(ADC1->CR2 & ADC_CR2_RSTCAL);
    
    ADC1->CR2 |= ADC_CR2_CAL;
    while(ADC1->CR2 & ADC_CR2_CAL);
}

// USART配置
void USART_Configuration(void)
{
    // 波特率配置 115200
    USART1->BRR = 0x0271;
    
    // 使能USART, 发送, 接收, 接收中断
    USART1->CR1 = USART_CR1_UE | USART_CR1_TE | USART_CR1_RE | USART_CR1_RXNEIE;
}

// NVIC配置
void NVIC_Configuration(void)
{
    NVIC->ISER[0] |= (1 << USART1_IRQn);  // 使能USART1中断
}

// 读取ADC值
uint16_t Read_ADC(uint8_t channel)
{
    // 设置通道
    ADC1->SQR3 = channel;
    
    // 启动转换
    ADC1->CR2 |= ADC_CR2_ADON;
    Delay_ms(1);
    ADC1->CR2 |= ADC_CR2_ADON;
    
    // 等待转换完成
    while(!(ADC1->SR & ADC_SR_EOC));
    
    return ADC1->DR;
}

// 延时函数
void Delay_ms(uint32_t nTime)
{
    volatile uint32_t i, j;
    for(i = 0; i < nTime; i++)
        for(j = 0; j < 8000; j++);
}

// 继电器控制
void Control_Relay(uint8_t state)
{
    if(state)
        GPIOC->BSRR = RELAY_PIN;  // 打开继电器
    else
        GPIOC->BRR = RELAY_PIN;   // 关闭继电器
    
    light_status = state;
}

// 读取光照强度
uint16_t Read_Light_Sensor(void)
{
    uint16_t adc_value = Read_ADC(LIGHT_SENSOR_ADC_CHANNEL);
    // 转换为光照强度值 (0-1000)
    return (adc_value * 1000) / 4095;
}

// 发送数据到Zigbee
void Send_To_Zigbee(uint8_t* data, uint8_t len)
{
    for(uint8_t i = 0; i < len; i++)
    {
        while(!(USART1->SR & USART_SR_TXE));
        USART1->DR = data[i];
    }
}

// 自动光照控制
void Auto_Light_Control(void)
{
    if(auto_mode)
    {
        if(light_level < 300)  // 光照阈值
            Control_Relay(1);  // 打开灯光
        else
            Control_Relay(0);  // 关闭灯光
    }
}

// 处理Zigbee命令
void Process_Zigbee_Command(uint8_t* cmd)
{
    switch(cmd[0])
    {
        case 'O':  // ON
            auto_mode = 0;
            Control_Relay(1);
            break;
        case 'F':  // OFF
            auto_mode = 0;
            Control_Relay(0);
            break;
        case 'A':  // AUTO
            auto_mode = 1;
            break;
        case 'G':  // GET_STATUS
            {
                uint8_t status_msg[4];
                status_msg[0] = 'S';
                status_msg[1] = light_status ? '1' : '0';
                status_msg[2] = (light_level / 100) + '0';
                status_msg[3] = (light_level % 100 / 10) + '0';
                Send_To_Zigbee(status_msg, 4);
            }
            break;
    }
}

// USART1中断服务函数
void USART1_IRQHandler(void)
{
    if(USART1->SR & USART_SR_RXNE)
    {
        uint8_t received_data = USART1->DR;
        Process_Zigbee_Command(&received_data);
    }
}

// 主函数
int main(void)
{
    // 系统初始化
    RCC_Configuration();
    GPIO_Configuration();
    ADC_Configuration();
    USART_Configuration();
    NVIC_Configuration();
    
    // 初始状态
    Control_Relay(0);
    
    while(1)
    {
        // 读取光照强度
        light_level = Read_Light_Sensor();
        
        // 自动控制
        Auto_Light_Control();
        
        // 延时
        Delay_ms(1000);
    }
}

项目核心代码

#include "stm32f10x.h"

// 引脚定义
#define LIGHT_SENSOR_PIN    GPIO_Pin_0   // PA0 - 光照传感器
#define RELAY_PIN           GPIO_Pin_1   // PA1 - 继电器控制
#define ZIGBEE_TX_PIN       GPIO_Pin_9   // PA9 - Zigbee TX
#define ZIGBEE_RX_PIN       GPIO_Pin_10  // PA10 - Zigbee RX

// 光照阈值
#define LIGHT_THRESHOLD     500

// 设备状态
typedef enum {
    LIGHT_OFF = 0,
    LIGHT_ON = 1
} LightState;

// 场景模式
typedef enum {
    MODE_NORMAL = 0,
    MODE_ALL_ON = 1,
    MODE_ALL_OFF = 2,
    MODE_NIGHT = 3
} SceneMode;

// 全局变量
volatile LightState currentLightState = LIGHT_OFF;
volatile SceneMode currentSceneMode = MODE_NORMAL;
volatile uint16_t lightSensorValue = 0;

// 函数声明
void System_Init(void);
void GPIO_Init(void);
void USART_Init(void);
void ADC_Init(void);
void TIM_Init(void);
uint16_t Read_Light_Sensor(void);
void Control_Light(LightState state);
void Process_Zigbee_Command(uint8_t* command);
void Send_Zigbee_Data(uint8_t* data, uint8_t len);
void Process_Scene_Mode(SceneMode mode);

int main(void)
{
    System_Init();
    
    while(1)
    {
        // 读取光照传感器值
        lightSensorValue = Read_Light_Sensor();
        
        // 自动模式下的光照控制
        if(currentSceneMode == MODE_NORMAL)
        {
            if(lightSensorValue < LIGHT_THRESHOLD)
            {
                Control_Light(LIGHT_ON);
            }
            else
            {
                Control_Light(LIGHT_OFF);
            }
        }
        else if(currentSceneMode == MODE_NIGHT)
        {
            // 夜间模式：仅在非常暗时开启
            if(lightSensorValue < (LIGHT_THRESHOLD / 2))
            {
                Control_Light(LIGHT_ON);
            }
            else
            {
                Control_Light(LIGHT_OFF);
            }
        }
        
        // 处理Zigbee通信
        if(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) != RESET)
        {
            uint8_t rxData[32];
            uint8_t index = 0;
            
            // 读取Zigbee数据
            while(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) != RESET && index < 32)
            {
                rxData[index++] = USART_ReceiveData(USART1);
            }
            
            // 处理命令
            Process_Zigbee_Command(rxData);
        }
        
        // 定时上报状态
        static uint32_t lastReportTime = 0;
        if(SystemCoreClock - lastReportTime > 5000000) // 5秒上报一次
        {
            uint8_t statusData[4];
            statusData[0] = 0xAA; // 帧头
            statusData[1] = currentLightState;
            statusData[2] = lightSensorValue >> 8;
            statusData[3] = lightSensorValue & 0xFF;
            
            Send_Zigbee_Data(statusData, 4);
            lastReportTime = SystemCoreClock;
        }
    }
}

void System_Init(void)
{
    // 开启时钟
    RCC->APB2ENR |= RCC_APB2ENR_IOPAEN | RCC_APB2ENR_AFIOEN | 
                    RCC_APB2ENR_USART1EN | RCC_APB2ENR_ADC1EN;
    
    GPIO_Init();
    USART_Init();
    ADC_Init();
    TIM_Init();
    
    // 配置NVIC
    NVIC_EnableIRQ(USART1_IRQn);
}

void GPIO_Init(void)
{
    // PA0 - 光照传感器输入
    GPIOA->CRL &= ~(GPIO_CRL_MODE0 | GPIO_CRL_CNF0);
    GPIOA->CRL |= GPIO_CRL_CNF0_1; // 模拟输入
    
    // PA1 - 继电器控制输出
    GPIOA->CRL &= ~(GPIO_CRL_MODE1 | GPIO_CRL_CNF1);
    GPIOA->CRL |= GPIO_CRL_MODE1_0; // 推挽输出，2MHz
    
    // PA9 - USART1 TX 复用推挽输出
    GPIOA->CRH &= ~(GPIO_CRH_MODE9 | GPIO_CRH_CNF9);
    GPIOA->CRH |= GPIO_CRH_MODE9_0 | GPIO_CRH_CNF9_1;
    
    // PA10 - USART1 RX 浮空输入
    GPIOA->CRH &= ~(GPIO_CRH_MODE10 | GPIO_CRH_CNF10);
    GPIOA->CRH |= GPIO_CRH_CNF10_0;
}

void USART_Init(void)
{
    // 波特率115200
    USART1->BRR = 72000000 / 115200;
    
    // 使能USART, RXNE中断, 收发使能
    USART1->CR1 = USART_CR1_UE | USART_CR1_RXNEIE | 
                  USART_CR1_TE | USART_CR1_RE;
}

void ADC_Init(void)
{
    // ADC1初始化
    ADC1->CR2 = ADC_CR2_ADON; // 开启ADC
    ADC1->SQR3 = 0; // 通道0
    ADC1->SQR1 = 0; // 1个转换
}

void TIM_Init(void)
{
    // 定时器用于延时和定时任务
    RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;
    TIM2->PSC = 7200 - 1; // 10kHz
    TIM2->ARR = 10000 - 1; // 1秒
    TIM2->CR1 = TIM_CR1_CEN;
}

uint16_t Read_Light_Sensor(void)
{
    ADC1->CR2 |= ADC_CR2_ADON;
    
    // 启动转换
    ADC1->CR2 |= ADC_CR2_SWSTART;
    
    // 等待转换完成
    while(!(ADC1->SR & ADC_SR_EOC));
    
    return ADC1->DR;
}

void Control_Light(LightState state)
{
    if(state == LIGHT_ON)
    {
        GPIOA->BSRR = RELAY_PIN; // 置位，开灯
        currentLightState = LIGHT_ON;
    }
    else
    {
        GPIOA->BRR = RELAY_PIN; // 复位，关灯
        currentLightState = LIGHT_OFF;
    }
}

void Process_Zigbee_Command(uint8_t* command)
{
    if(command[0] == 0x55) // 命令帧头
    {
        switch(command[1])
        {
            case 0x01: // 开关控制
                Control_Light((LightState)command[2]);
                break;
                
            case 0x02: // 场景模式
                Process_Scene_Mode((SceneMode)command[2]);
                break;
                
            case 0x03: // 状态查询
                {
                    uint8_t status[3];
                    status[0] = 0xBB;
                    status[1] = currentLightState;
                    status[2] = currentSceneMode;
                    Send_Zigbee_Data(status, 3);
                }
                break;
        }
    }
}

void Send_Zigbee_Data(uint8_t* data, uint8_t len)
{
    for(uint8_t i = 0; i < len; i++)
    {
        while(!(USART1->SR & USART_SR_TXE));
        USART1->DR = data[i];
    }
}

void Process_Scene_Mode(SceneMode mode)
{
    currentSceneMode = mode;
    
    switch(mode)
    {
        case MODE_ALL_ON:
            Control_Light(LIGHT_ON);
            break;
            
        case MODE_ALL_OFF:
            Control_Light(LIGHT_OFF);
            break;
            
        case MODE_NIGHT:
            // 夜间模式逻辑在main循环中处理
            break;
            
        case MODE_NORMAL:
            // 正常模式逻辑在main循环中处理
            break;
    }
}

// USART1中断服务函数
void USART1_IRQHandler(void)
{
    if(USART1->SR & USART_SR_RXNE)
    {
        // RXNE标志会在读取DR时自动清除
        volatile uint8_t temp = USART1->DR;
    }
}

总结

该系统基于Zigbee无线通信技术，成功构建了一个高效、灵活的智能家居灯光控制系统。通过协调器、路由器和终端设备的协同工作，系统实现了稳定的网络组建，支持环境光照强度的实时监测与灯具的智能控制，为用户提供便捷的远程操作体验。

硬件方面，系统采用STM32单片机与Zigbee模块（如CC2530）作为核心控制单元，结合光敏电阻模块进行光照感知，继电器模块执行灯光开关操作，并通过Zigbee-USB协调器连接上位机或网关，确保手机APP能够远程控制任意房间的灯光。

整体而言，该系统不仅支持多种场景模式，如“全开”、“全关”和“夜间模式”，还提升了家居自动化的智能化水平和能源效率，适用于现代家庭和商业环境，充分体现了Zigbee技术在智能家居领域的应用优势。