基于ESP32-S3设计的西瓜育苗监控系统

一、前言

1.1 项目开发背景

我国是全球最大的西瓜生产与消费国，西瓜产业在农业经济中占据重要地位。然而，西瓜育苗过程对环境条件极为敏感，温度、湿度、光照、土壤水分和二氧化碳浓度等因素直接影响种苗的成活率与后期长势。传统育苗管理主要依赖人工经验判断和手动操作，不仅劳动强度大、效率低下，而且难以做到精准控制，尤其在规模化大棚生产中，环境参数的细微波动可能导致大面积损失。随着设施农业的快速发展，大棚西瓜育苗对智能化、自动化的管理手段需求日益迫切，这为物联网技术在农业领域的深入应用提供了广阔空间。

近年来，物联网、嵌入式系统、云计算和移动互联网技术的迅猛发展为农业环境监控提供了全新的技术路径。通过传感器实时采集环境与土壤数据，结合自动控制执行机构，可以实现对育苗环境的闭环调控。同时，4G通信技术的普及使得偏远农田、户外大棚等不具备有线网络和Wi-Fi覆盖的场景也能稳定接入互联网云端平台，实现数据的远程汇聚与设备远程操控。这种“端-云-应用”的物联网架构正在成为智慧农业领域的主流技术方案，能够有效解决农业生产地域分散、管理滞后的痛点。

华为云IoT物联网平台作为成熟的企业级云服务，具备高并发连接、安全可靠的数据传输和丰富的设备管理功能，为农业物联网设备提供了稳定的数据汇聚与控制指令下发通道。配合MQTT轻量级消息协议，能够在低带宽、不稳定的网络环境下保持高效通信，特别适合农业大棚等户外场景。通过云平台，不仅可以实时查看育苗环境的各项关键指标，还能将历史数据进行存储和分析，为后续的种植优化决策提供数据支撑。

在终端设备层面，ESP32-S3系列芯片凭借其强大的双核处理器、丰富的外设接口和较低的功耗表现，已成为工业及农业物联网终端设计的优选平台。搭配高精度的数字式传感器如SHT30温湿度传感器、BH1750光照传感器和SGP30二氧化碳传感器，能够满足育苗环境监测的精度与稳定性要求。同时，通过本地LCD显示屏和按键的人机交互设计，即便在网络中断的极端情况下，现场操作人员依然能够获取实时数据并进行手动控制，保证了系统的可靠性与可用性。

在控制执行方面，系统通过继电器驱动电磁阀实现自动灌溉补水，结合土壤湿度传感器的反馈形成闭环控制逻辑，能够在自动模式下根据预设阈值智能启动或停止灌溉，避免因浇水不当导致的沤根或干旱。补光灯和通风风扇的自动控制则分别应对弱光天气和高温环境，为西瓜幼苗提供最适宜的生长微气候。而手动模式与自动模式的双重设计，既保留了自动化管理的便利性，也兼顾了特殊情况下人工干预的灵活性，体现了农业智能系统设计中“人机协同”的务实理念。

在应用层开发上，采用Qt框架设计Android手机APP和Windows上位机软件，不仅保证了跨平台代码的复用性，也提供了统一的用户界面风格和良好的交互体验。种植管理者可以随时随地通过手机查看大棚内的实时环境数据、接收报警信息，并可远程下达灌溉、补光、通风等控制指令，真正实现了“不在大棚，胜在大棚”的远程管理模式。Windows上位机则更适合在集中控制室内进行多棚区的综合监控与数据管理，满足不同层级用户的使用习惯和场景需求。

综上所述，本项目的开发紧密结合了我国西瓜育苗产业的实际生产需求与当前物联网、嵌入式、云计算等前沿技术发展现状，旨在设计一套低成本、高可靠性、易于部署和操作的智能化育苗环境监控系统。该系统不仅能够有效提升西瓜育苗的成活率和品质，降低人工管理成本，同时也为其他设施园艺作物的智能化管理提供可借鉴的技术方案，对推动我国农业现代化和智慧农业发展具有积极的实践意义。

下面是第一版本的硬件，采用模块化方式设计

下面是成品:

1.2 设计实现的功能

（1）支持实时检测土壤湿度、环境温度、环境湿度、环境光强和二氧化碳浓度共计五项环境参数，所有传感器数据通过ESP32-S3主控芯片采集处理。

（2）本地配备1.44寸SPI协议LCD显示屏，可实时显示所有传感器采集到的数据，方便现场人员直观查看大棚内的环境状态。

（3）本地设有实体按钮，支持手动控制补水灌溉操作；同时支持远程控制补水，补水执行机构采用继电器驱动电磁阀，对灌溉区域进行喷洒灌溉。

（4）设备通过Air724 4G模块以MQTT协议连接华为云IoT物联网服务器，将采集的所有传感器数据上传至云端，实现设备数据上云。

（5）分别设计基于Qt5框架的Android手机APP和Windows上位机软件，通过华为云IoT平台实现远程查看设备上传的实时数据，并支持远程下发灌溉控制指令。

（6）设备支持两种控制模式：手动模式和自动模式。自动模式下，系统根据检测到的土壤湿度数值与预设的土壤湿度阈值进行比较，自动判断是否需要启动浇水；手动模式下，可通过本地按钮和手机APP两种途径进行手动灌溉控制。

（7）支持补光灯的自动开关控制。自动模式下，系统根据环境光照强度自动开启或关闭补光LED灯；手动模式下，可通过本地按钮和手机APP两种途径进行补光灯的手动开关控制。

（8）支持通风风扇的自动控制。自动模式下，当大棚内环境温度超过预设的阈值时，系统自动打开通风风扇进行通风换气降温。

（9）云端上报数据遵循华为云IoT平台标准格式，上报数据包含：环境温度（SHT30_T）、环境湿度（SHT30_H）、环境光照强度（BH1750）、补光灯开关状态（LED_SW）、土壤湿度（SOIL）、灌溉电机开关状态（MOTOR_SW）、运行模式（mode_type）、土壤湿度阈值（SOIL_MIN）、二氧化碳浓度（SGP30）、通风风扇开关状态（FEN_MOTOR_SW）共计十项属性。

（10）系统控制板采用外部5V 2A电源供电，为ESP32-S3主控、传感器、4G模块、LCD显示屏及继电器等所有板载设备提供稳定电源。

1.3 项目硬件模块组成

（1）主控芯片：采用乐鑫ESP32-S3-R8N8芯片，作为整个系统的核心处理器，负责传感器数据采集、逻辑运算、显示驱动、4G通信控制及继电器输出控制。

（2）环境温湿度传感器：采用SHT30数字式温湿度传感器，用于采集大棚内的环境温度和环境湿度数据，通过I2C接口与ESP32-S3通信。

（3）环境光照强度传感器：采用BH1750数字式光照传感器，用于采集大棚内的环境光强数据，通过I2C接口与ESP32-S3通信。

（4）二氧化碳传感器：采用SGP30传感器，用于采集大棚内的二氧化碳浓度数据，通过I2C接口与ESP32-S3通信。

（5）土壤湿度传感器：采用ADC模拟量接口的土壤湿度检测传感器，通过将土壤湿度转换为模拟电压信号接入ESP32-S3的ADC引脚，实现土壤湿度的实时检测。

（6）LCD显示屏：采用1.44寸SPI协议显示屏，用于本地实时显示所有传感器采集的数据，通过SPI接口与ESP32-S3通信。

（7）4G通信模块：采用Air724 4G模块，用于设备通过MQTT协议连接华为云IoT物联网服务器，实现传感器数据上报和远程控制指令接收，通过UART串口与ESP32-S3通信。

（8）补光灯模块：采用白色LED灯作为补光光源，通过继电器控制其开关，由ESP32-S3的GPIO引脚输出控制信号驱动继电器动作。

（9）通风风扇模块：采用5V小风扇，通过继电器控制其开关，由ESP32-S3的GPIO引脚输出控制信号驱动继电器动作，用于大棚内的通风换气。

（10）灌溉执行模块：采用继电器驱动电磁阀，由ESP32-S3的GPIO引脚输出控制信号驱动继电器动作，控制电磁阀通断以实现对灌溉区域的喷洒灌溉。

（11）本地控制按钮：设有本地实体按钮，用于手动控制补水、补光灯及运行模式切换等操作，按钮信号接入ESP32-S3的GPIO输入引脚。

（12）电源模块：系统控制板采用外部5V 2A电源供电，为ESP32-S3主控芯片、所有传感器、4G模块、LCD显示屏、继电器及各执行机构提供工作电源。

1.4 系统框架图

1.5 运行流程图

二、部署华为云物联网平台

华为云官网: https://www.huaweicloud.com/

打开官网，搜索物联网，就能快速找到 设备接入IoTDA。

2.1 物联网平台介绍

华为云物联网平台（IoT 设备接入云服务）提供海量设备的接入和管理能力，将物理设备联接到云，支撑设备数据采集上云和云端下发命令给设备进行远程控制，配合华为云其他产品，帮助我们快速构筑物联网解决方案。

使用物联网平台构建一个完整的物联网解决方案主要包括3部分：物联网平台、业务应用和设备。

物联网平台作为连接业务应用和设备的中间层，屏蔽了各种复杂的设备接口，实现设备的快速接入；同时提供强大的开放能力，支撑行业用户构建各种物联网解决方案。

设备可以通过固网、2G/3G/4G/5G、NB-IoT、Wifi等多种网络接入物联网平台，并使用LWM2M/CoAP、MQTT、HTTPS协议将业务数据上报到平台，平台也可以将控制命令下发给设备。

业务应用通过调用物联网平台提供的API，实现设备数据采集、命令下发、设备管理等业务场景。

2.2 开通物联网服务

地址： https://www.huaweicloud.com/product/iothub.html

开通免费单元。

点击立即创建。

正在创建标准版实例，需要等待片刻。

创建完成之后，点击详情。 可以看到标准版实例的设备接入端口和地址。

下面框起来的就是端口号和域名

点击实例名称，可以查看当前免费单元的配置情况。

开通之后，点击接入信息，也能查看接入信息。 我们当前设备准备采用MQTT协议接入华为云平台，这里可以看到MQTT协议的地址和端口号等信息。

总结:

端口号：   MQTT (1883)| MQTTS (8883)    
接入地址： dab1a1f2c6.st1.iotda-device.cn-north-4.myhuaweicloud.com

根据域名地址得到IP地址信息:

打开Windows电脑的命令行控制台终端，使用ping 命令。ping一下即可。

Microsoft Windows [版本 10.0.19045.5011]
(c) Microsoft Corporation。保留所有权利。

C:UsersLenovo>ping dab1a1f2c6.st1.iotda-device.cn-north-4.myhuaweicloud.com

正在 Ping dab1a1f2c6.st1.iotda-device.cn-north-4.myhuaweicloud.com [117.78.5.125] 具有 32 字节的数据:
来自 117.78.5.125 的回复: 字节=32 时间=37ms TTL=44
来自 117.78.5.125 的回复: 字节=32 时间=37ms TTL=44
来自 117.78.5.125 的回复: 字节=32 时间=37ms TTL=44
来自 117.78.5.125 的回复: 字节=32 时间=37ms TTL=44

117.78.5.125 的 Ping 统计信息:
    数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
往返行程的估计时间(以毫秒为单位):
    最短 = 37ms，最长 = 37ms，平均 = 37ms

C:UsersLenovo>

MQTT协议接入端口号有两个，1883是非加密端口，8883是证书加密端口，单片机无法加载证书，所以使用1883端口合适。

2.3 创建产品

链接：https://console.huaweicloud.com/iotdm/?region=cn-north-4#/dm-dev/all-product?instanceId=03c5c68c-e588-458c-90c3-9e4c640be7af

（1）创建产品

（2）填写产品信息

根据自己产品名字填写，下面的设备类型选择自定义类型。

（3）产品创建成功

创建完成之后点击查看详情。

（4）添加自定义模型

产品创建完成之后，点击进入产品详情页面，翻到最下面可以看到模型定义。

模型简单来说： 就是存放设备上传到云平台的数据。

你可以根据自己的产品进行创建。

比如：

烟雾可以叫  MQ2
温度可以叫  Temperature
湿度可以叫  humidity
火焰可以叫  flame
其他的传感器自己用单词简写命名即可。 这就是你的单片机设备端上传到服务器的数据名字。

先点击自定义模型。

再创建一个服务ID。

接着点击新增属性。

2.4 添加设备

产品是属于上层的抽象模型，接下来在产品模型下添加实际的设备。添加的设备最终需要与真实的设备关联在一起，完成数据交互。

（1）注册设备

（2）根据自己的设备填写

（3）保存设备信息

创建完毕之后，点击保存并关闭，得到创建的设备密匙信息。该信息在后续生成MQTT三元组的时候需要使用。

（4）设备创建完成

（5）设备详情

2.5 MQTT协议主题订阅与发布

（1）MQTT协议介绍

当前的设备是采用MQTT协议与华为云平台进行通信。

MQTT是一个物联网传输协议，它被设计用于轻量级的发布/订阅式消息传输，旨在为低带宽和不稳定的网络环境中的物联网设备提供可靠的网络服务。MQTT是专门针对物联网开发的轻量级传输协议。MQTT协议针对低带宽网络，低计算能力的设备，做了特殊的优化，使得其能适应各种物联网应用场景。目前MQTT拥有各种平台和设备上的客户端，已经形成了初步的生态系统。

MQTT是一种消息队列协议，使用发布/订阅消息模式，提供一对多的消息发布，解除应用程序耦合，相对于其他协议，开发更简单；MQTT协议是工作在TCP/IP协议上；由TCP/IP协议提供稳定的网络连接；所以，只要具备TCP协议栈的网络设备都可以使用MQTT协议。  本次设备采用的ESP8266就具备TCP协议栈，能够建立TCP连接，所以，配合STM32代码里封装的MQTT协议，就可以与华为云平台完成通信。

华为云的MQTT协议接入帮助文档在这里:  https://support.huaweicloud.com/devg-iothub/iot_02_2200.html

业务流程：

（2）华为云平台MQTT协议使用限制

描述	限制
支持的MQTT协议版本	3.1.1
与标准MQTT协议的区别	支持Qos 0和Qos 1支持Topic自定义不支持QoS2不支持will、retain msg
MQTTS支持的安全等级	采用TCP通道基础 + TLS协议（最高TLSv1.3版本）
单帐号每秒最大MQTT连接请求数	无限制
单个设备每分钟支持的最大MQTT连接数	1
单个MQTT连接每秒的吞吐量，即带宽，包含直连设备和网关	3KB/s
MQTT单个发布消息最大长度，超过此大小的发布请求将被直接拒绝	1MB
MQTT连接心跳时间建议值	心跳时间限定为30至1200秒，推荐设置为120秒
产品是否支持自定义Topic	支持
消息发布与订阅	设备只能对自己的Topic进行消息发布与订阅
每个订阅请求的最大订阅数	无限制

（3）主题订阅格式

帮助文档地址：https://support.huaweicloud.com/devg-iothub/iot_02_2200.html

对于设备而言，一般会订阅平台下发消息给设备 这个主题。

设备想接收平台下发的消息，就需要订阅平台下发消息给设备 的主题，订阅后，平台下发消息给设备，设备就会收到消息。

如果设备想要知道平台下发的消息，需要订阅上面图片里标注的主题。

以当前设备为例，最终订阅主题的格式如下:
$oc/devices/{device_id}/sys/messages/down
    
最终的格式:
$oc/devices/663cb18871d845632a0912e7_dev1/sys/messages/down

（4）主题发布格式

对于设备来说，主题发布表示向云平台上传数据，将最新的传感器数据，设备状态上传到云平台。

这个操作称为：属性上报。

帮助文档地址：https://support.huaweicloud.com/usermanual-iothub/iot_06_v5_3010.html

根据帮助文档的介绍， 当前设备发布主题，上报属性的格式总结如下：

发布的主题格式:
$oc/devices/{device_id}/sys/properties/report
 
最终的格式:
$oc/devices/663cb18871d845632a0912e7_dev1/sys/properties/report
发布主题时，需要上传数据，这个数据格式是JSON格式。

上传的JSON数据格式如下:

{
  "services": [
    {
      "service_id": <填服务ID>,
      "properties": {
        "<填属性名称1>": <填属性值>,
        "<填属性名称2>": <填属性值>,
        ..........
      }
    }
  ]
}
根据JSON格式，一次可以上传多个属性字段。 这个JSON格式里的，服务ID，属性字段名称，属性值类型，在前面创建产品的时候就已经介绍了，不记得可以翻到前面去查看。

根据这个格式，组合一次上传的属性数据:
{"services": [{"service_id": "stm32","properties":{"你的字段名字1":30,"你的字段名字2":10,"你的字段名字3":1,"你的字段名字4":0}}]}

2.6 MQTT三元组

MQTT协议登录需要填用户ID，设备ID，设备密码等信息，就像我们平时登录QQ，微信一样要输入账号密码才能登录。MQTT协议登录的这3个参数，一般称为MQTT三元组。

接下来介绍，华为云平台的MQTT三元组参数如何得到。

（1）MQTT服务器地址

要登录MQTT服务器，首先记得先知道服务器的地址是多少，端口是多少。

帮助文档地址：https://console.huaweicloud.com/iotdm/?region=cn-north-4#/dm-portal/home

MQTT协议的端口支持1883和8883，它们的区别是：8883 是加密端口更加安全。但是单片机上使用比较困难，所以当前的设备是采用1883端口进连接的。

根据上面的域名和端口号，得到下面的IP地址和端口号信息：   如果设备支持填写域名可以直接填域名，不支持就直接填写IP地址。  （IP地址就是域名解析得到的）

华为云的MQTT服务器地址：117.78.5.125
华为云的MQTT端口号：1883

如何得到IP地址？如何域名转IP？  打开Windows的命令行输入以下命令。

ping  ad635970a1.st1.iotda-device.cn-north-4.myhuaweicloud.com

（2）生成MQTT三元组

华为云提供了一个在线工具，用来生成MQTT鉴权三元组： https://iot-tool.obs-website.cn-north-4.myhuaweicloud.com/

打开这个工具，填入设备的信息（也就是刚才创建完设备之后保存的信息），点击生成，就可以得到MQTT的登录信息了。

下面是打开的页面：

填入设备的信息：   （上面两行就是设备创建完成之后保存得到的）

直接得到三元组信息。

得到三元组之后，设备端通过MQTT协议登录鉴权的时候，填入参数即可。

ClientId  663cb18871d845632a0912e7_dev1_0_0_2024050911
Username  663cb18871d845632a0912e7_dev1
Password  71b82deae83e80f04c4269b5bbce3b2fc7c13f610948fe210ce18650909ac237

2.7 模拟设备登录测试

经过上面的步骤介绍，已经创建了产品，设备，数据模型，得到MQTT登录信息。 接下来就用MQTT客户端软件模拟真实的设备来登录平台。测试与服务器通信是否正常。

MQTT软件下载地址【免费】： https://download.csdn.net/download/xiaolong1126626497/89928772

（1）填入登录信息

打开MQTT客户端软件，对号填入相关信息（就是上面的文本介绍）。然后，点击登录，订阅主题，发布主题。

（2）打开网页查看

完成上面的操作之后，打开华为云网页后台，可以看到设备已经在线了。

点击详情页面，可以看到上传的数据：

到此，云平台的部署已经完成，设备已经可以正常上传数据了。

（3）MQTT登录测试参数总结

MQTT服务器:  117.78.5.125
MQTT端口号:  183

//物联网服务器的设备信息
#define MQTT_ClientID "663cb18871d845632a0912e7_dev1_0_0_2024050911"
#define MQTT_UserName "663cb18871d845632a0912e7_dev1"
#define MQTT_PassWord "71b82deae83e80f04c4269b5bbce3b2fc7c13f610948fe210ce18650909ac237"

//订阅与发布的主题
#define SET_TOPIC  "$oc/devices/663cb18871d845632a0912e7_dev1/sys/messages/down"  //订阅
#define POST_TOPIC "$oc/devices/663cb18871d845632a0912e7_dev1/sys/properties/report"  //发布


发布的数据:
{"services": [{"service_id": "stm32","properties":{"你的字段名字1":30,"你的字段名字2":10,"你的字段名字3":1,"你的字段名字4":0}}]}

2.8 创建IAM账户

创建一个IAM账户，因为接下来开发上位机，需要使用云平台的API接口，这些接口都需要token进行鉴权。简单来说，就是身份的认证。  调用接口获取Token时，就需要填写IAM账号信息。所以，接下来演示一下过程。

地址:  https://console.huaweicloud.com/iam/?region=cn-north-4#/iam/users

**【1】获取项目凭证 **  点击左上角用户名，选择下拉菜单里的我的凭证

项目凭证:

28add376c01e4a61ac8b621c714bf459

【2】创建IAM用户

鼠标放在左上角头像上，在下拉菜单里选择统一身份认证。

点击左上角创建用户。

创建成功：

【3】创建完成

用户信息如下：

主用户名  l19504562721
IAM用户  ds_abc
密码     DS12345678

2.9 获取影子数据

帮助文档：https://support.huaweicloud.com/api-iothub/iot_06_v5_0079.html

设备影子介绍：

设备影子是一个用于存储和检索设备当前状态信息的JSON文档。
每个设备有且只有一个设备影子，由设备ID唯一标识
设备影子仅保存最近一次设备的上报数据和预期数据
无论该设备是否在线，都可以通过该影子获取和设置设备的属性

简单来说：设备影子就是保存，设备最新上传的一次数据。

我们设计的软件里，如果想要获取设备的最新状态信息，就采用设备影子接口。

如果对接口不熟悉，可以先进行在线调试：https://apiexplorer.developer.huaweicloud.com/apiexplorer/doc?product=IoTDA&api=ShowDeviceShadow

在线调试接口，可以请求影子接口，了解请求，与返回的数据格式。

调试完成看右下角的响应体，就是返回的影子数据。

设备影子接口返回的数据如下：

{
 "device_id": "663cb18871d845632a0912e7_dev1",
 "shadow": [
  {
   "service_id": "stm32",
   "desired": {
    "properties": null,
    "event_time": null
   },
   "reported": {
    "properties": {
     "DHT11_T": 18,
     "DHT11_H": 90,
     "BH1750": 38,
     "MQ135": 70
    },
    "event_time": "20240509T113448Z"
   },
   "version": 3
  }
 ]
}

调试成功之后，可以得到访问影子数据的真实链接，接下来的代码开发中，就采用Qt写代码访问此链接，获取影子数据，完成上位机开发。

链接如下：

https://ad635970a1.st1.iotda-app.cn-north-4.myhuaweicloud.com:443/v5/iot/28add376c01e4a61ac8b621c714bf459/devices/663cb18871d845632a0912e7_dev1/shadow

三、上位机开发

3.1 Qt开发环境安装

Qt的中文官网： https://www.qt.io/zh-cn/

QT5.12.6的下载地址：https://download.qt.io/archive/qt/5.12/5.12.6

打开下载链接后选择下面的版本进行下载：

如果下载不了，可以在网盘里找到安装包下载：    飞书文档记录的网盘地址：https://ccnr8sukk85n.feishu.cn/wiki/QjY8weDYHibqRYkFP2qcA9aGnvb?from=from_copylink

软件安装时断网安装，否则会提示输入账户。

安装的时候，第一个复选框里的编译器可以全选，直接点击下一步继续安装。

选择编译器： （一定要看清楚了）

3.2 新建上位机工程

前面2讲解了需要用的API接口，接下来就使用Qt设计上位机，设计界面，完成整体上位机的逻辑设计。

【1】新建工程

【2】设置项目的名称。

【3】选择编译系统

【4】选择默认继承的类

【5】选择编译器

【6】点击完成

【7】工程创建完成

3.3 切换编译器

在左下角是可以切换编译器的。 可以选择用什么样的编译器编译程序。

目前新建工程的时候选择了2种编译器。 一种是mingw32这个编译Windows下运行的程序。 一种是Android编译器，可以生成Android手机APP。

不过要注意：Android的编译器需要配置一些环境才可以正常使用，这个大家可以网上找找教程配置一下就行了。

windows的编译器就没有这么麻烦，安装好Qt就可以编译使用。

下面我这里就选择的 mingw32这个编译器，编译Windows下运行的程序。

3.4 编译测试功能

创建完毕之后，编译测试一下功能是否OK。

点击左下角的绿色三角形按钮。

正常运行就可以看到弹出一个白色的框框。这就表示工程环境没有问题了。 接下来就可以放心的设计界面了。

3.5 设计UI界面与工程配置

打开默认的界面如下：

3.6 设计代码

// widget.cpp
#include "widget.h"
#include "ui_widget.h"
#include <QMessageBox>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QDebug>

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
    , m_mqttClient(new QMqttClient(this))
    , m_connected(false)
{
    ui->setupUi(this);

    // 初始化UI控件状态
    ui->lineEdit_Broker->setText("20d1e33470.st1.iotda-device.cn-north-4.myhuaweicloud.com");
    ui->lineEdit_Port->setText("1883");
    ui->lineEdit_ClientID->setText("67c7dff98e04aa0690ba6341_dev1_0_0_2025030505");
    ui->lineEdit_Username->setText("67c7dff98e04aa0690ba6341_dev1");
    ui->lineEdit_Password->setText("b3894902a6e1ff3571f2f93363aa1019618853f64b78faf09af2afd3561fec67");
    ui->lineEdit_SubscribeTopic->setText("$oc/devices/67c7dff98e04aa0690ba6341_dev1/sys/messages/down");
    ui->lineEdit_PublishTopic->setText("$oc/devices/67c7dff98e04aa0690ba6341_dev1/sys/properties/report");
    ui->lineEdit_DeviceId->setText("67c7dff98e04aa0690ba6341_dev1");

    // 初始状态显示
    ui->label_ConnectStatus->setText("未连接");
    ui->label_ConnectStatus->setStyleSheet("color: red");
    ui->pushButton_Connect->setText("连接");

    // 控制按钮初始状态（未连接时不可用）
    setControlsEnabled(false);

    // 信号槽连接
    connect(ui->pushButton_Connect, &QPushButton::clicked, this, &Widget::onConnectButtonClicked);
    connect(ui->pushButton_Refresh, &QPushButton::clicked, this, &Widget::onRefreshButtonClicked);
    connect(ui->pushButton_MotorOn, &QPushButton::clicked, this, &Widget::onMotorOnClicked);
    connect(ui->pushButton_MotorOff, &QPushButton::clicked, this, &Widget::onMotorOffClicked);
    connect(ui->pushButton_LedOn, &QPushButton::clicked, this, &Widget::onLedOnClicked);
    connect(ui->pushButton_LedOff, &QPushButton::clicked, this, &Widget::onLedOffClicked);
    connect(ui->pushButton_FanOn, &QPushButton::clicked, this, &Widget::onFanOnClicked);
    connect(ui->pushButton_FanOff, &QPushButton::clicked, this, &Widget::onFanOffClicked);
    connect(ui->pushButton_ModeAuto, &QPushButton::clicked, this, &Widget::onModeAutoClicked);
    connect(ui->pushButton_ModeManual, &QPushButton::clicked, this, &Widget::onModeManualClicked);
    connect(ui->pushButton_SetSoilMin, &QPushButton::clicked, this, &Widget::onSetSoilMinClicked);

    // MQTT信号槽
    connect(m_mqttClient, &QMqttClient::stateChanged, this, &Widget::onMqttStateChanged);
    connect(m_mqttClient, &QMqttClient::messageReceived, this, &Widget::onMqttMessageReceived);
    connect(m_mqttClient, &QMqttClient::pingResponseReceived, this, &Widget::onPingResponseReceived);

    // 定时器：定时发布数据（模拟上报）
    m_timer = new QTimer(this);
    connect(m_timer, &QTimer::timeout, this, &Widget::onPublishDataTimer);
    m_timer->setInterval(5000); // 5秒上报一次
}

Widget::~Widget()
{
    if (m_mqttClient->state() == QMqttClient::Connected) {
        m_mqttClient->disconnect();
    }
    delete ui;
}

void Widget::setControlsEnabled(bool enabled)
{
    ui->pushButton_Refresh->setEnabled(enabled);
    ui->pushButton_MotorOn->setEnabled(enabled);
    ui->pushButton_MotorOff->setEnabled(enabled);
    ui->pushButton_LedOn->setEnabled(enabled);
    ui->pushButton_LedOff->setEnabled(enabled);
    ui->pushButton_FanOn->setEnabled(enabled);
    ui->pushButton_FanOff->setEnabled(enabled);
    ui->pushButton_ModeAuto->setEnabled(enabled);
    ui->pushButton_ModeManual->setEnabled(enabled);
    ui->pushButton_SetSoilMin->setEnabled(enabled);
    ui->lineEdit_SoilMin->setEnabled(enabled);
}

void Widget::onConnectButtonClicked()
{
    if (m_connected) {
        // 断开连接
        m_mqttClient->disconnect();
        m_timer->stop();
        m_connected = false;
        ui->label_ConnectStatus->setText("未连接");
        ui->label_ConnectStatus->setStyleSheet("color: red");
        ui->pushButton_Connect->setText("连接");
        setControlsEnabled(false);
        return;
    }

    // 连接MQTT服务器
    m_mqttClient->setHostname(ui->lineEdit_Broker->text());
    m_mqttClient->setPort(ui->lineEdit_Port->text().toInt());
    m_mqttClient->setClientId(ui->lineEdit_ClientID->text());
    m_mqttClient->setUsername(ui->lineEdit_Username->text());
    m_mqttClient->setPassword(ui->lineEdit_Password->text());
    m_mqttClient->setKeepAlive(60); // 心跳间隔60秒
    m_mqttClient->setCleanSession(true);

    qDebug() << "Connecting to MQTT broker...";
    m_mqttClient->connectToHost();
}

void Widget::onMqttStateChanged(QMqttClient::ClientState state)
{
    qDebug() << "MQTT State changed:" << state;
    switch (state) {
    case QMqttClient::Connected:
        ui->label_ConnectStatus->setText("已连接");
        ui->label_ConnectStatus->setStyleSheet("color: green");
        ui->pushButton_Connect->setText("断开");
        m_connected = true;
        setControlsEnabled(true);

        // 订阅下行Topic
        QString subscribeTopic = ui->lineEdit_SubscribeTopic->text();
        auto subscription = m_mqttClient->subscribe(subscribeTopic, 1);
        if (subscription) {
            qDebug() << "Subscribe success:" << subscribeTopic;
        } else {
            qDebug() << "Subscribe failed:" << subscribeTopic;
        }

        // 启动定时上报
        m_timer->start();
        break;

    case QMqttClient::Disconnected:
        ui->label_ConnectStatus->setText("已断开");
        ui->label_ConnectStatus->setStyleSheet("color: red");
        ui->pushButton_Connect->setText("连接");
        m_connected = false;
        setControlsEnabled(false);
        m_timer->stop();
        break;

    default:
        ui->label_ConnectStatus->setText("连接中...");
        ui->label_ConnectStatus->setStyleSheet("color: orange");
        break;
    }
}

void Widget::onMqttMessageReceived(const QByteArray &message, const QMqttTopicName &topic)
{
    qDebug() << "Message received from:" << topic.name();
    qDebug() << "Message:" << message;

    // 解析JSON消息
    QJsonParseError error;
    QJsonDocument doc = QJsonDocument::fromJson(message, &error);
    if (error.error != QJsonParseError::NoError) {
        qDebug() << "JSON parse error:" << error.errorString();
        return;
    }

    if (!doc.isObject()) {
        qDebug() << "Message is not JSON object";
        return;
    }

    QJsonObject rootObj = doc.object();
    // 华为云平台下行消息格式解析（实际格式可能略有差异，根据平台实际下发格式调整）
    if (rootObj.contains("command_name")) {
        QString cmdName = rootObj.value("command_name").toString();
        QJsonObject paras = rootObj.value("paras").toObject();

        if (cmdName == "MOTOR_SW") {
            bool motorStatus = paras.value("value").toBool();
            ui->label_MotorStatus->setText(motorStatus ? "开启" : "关闭");
            ui->label_MotorStatus->setStyleSheet(motorStatus ? "color: green" : "color: red");
            qDebug() << "Motor status updated by cloud:" << motorStatus;
        } else if (cmdName == "LED_SW") {
            bool ledStatus = paras.value("value").toBool();
            ui->label_LedStatus->setText(ledStatus ? "开启" : "关闭");
            ui->label_LedStatus->setStyleSheet(ledStatus ? "color: green" : "color: red");
            qDebug() << "LED status updated by cloud:" << ledStatus;
        } else if (cmdName == "FEN_MOTOR_SW") {
            bool fanStatus = paras.value("value").toBool();
            ui->label_FanStatus->setText(fanStatus ? "开启" : "关闭");
            ui->label_FanStatus->setStyleSheet(fanStatus ? "color: green" : "color: red");
            qDebug() << "Fan status updated by cloud:" << fanStatus;
        } else if (cmdName == "mode_type") {
            bool mode = paras.value("value").toBool();
            ui->label_ModeStatus->setText(mode ? "自动模式" : "手动模式");
            ui->label_ModeStatus->setStyleSheet(mode ? "color: blue" : "color: orange");
            qDebug() << "Mode updated by cloud:" << mode;
        } else if (cmdName == "SOIL_MIN") {
            int soilMin = paras.value("value").toInt();
            ui->lineEdit_SoilMin->setText(QString::number(soilMin));
            qDebug() << "Soil min threshold updated by cloud:" << soilMin;
        }
    }
}

void Widget::onPingResponseReceived()
{
    qDebug() << "Ping response received";
}

void Widget::onRefreshButtonClicked()
{
    // 手动刷新，发布一次数据（实际由定时器定时发布）
    onPublishDataTimer();
}

void Widget::onPublishDataTimer()
{
    if (!m_connected) {
        return;
    }

    // 模拟生成传感器数据
    double temp = 18.0 + (rand() % 50) / 10.0;      // 18.0 ~ 22.9
    double humi = 15.0 + (rand() % 40) / 10.0;      // 15.0 ~ 18.9
    double light = 100 + rand() % 200;              // 100 ~ 299
    double soil = 25.0 + (rand() % 100) / 10.0;     // 25.0 ~ 34.9
    int co2 = 350 + rand() % 100;                   // 350 ~ 449

    // 获取当前界面显示的控制状态
    bool motorSw = (ui->label_MotorStatus->text() == "开启");
    bool ledSw = (ui->label_LedStatus->text() == "开启");
    bool fanSw = (ui->label_FanStatus->text() == "开启");
    bool modeType = (ui->label_ModeStatus->text() == "自动模式");
    int soilMin = ui->lineEdit_SoilMin->text().toInt();

    // 更新显示
    ui->label_Temp->setText(QString::number(temp, 'f', 1) + " °C");
    ui->label_Humi->setText(QString::number(humi, 'f', 1) + " %");
    ui->label_Light->setText(QString::number(light, 'f', 0) + " Lux");
    ui->label_Soil->setText(QString::number(soil, 'f', 1) + " %");
    ui->label_CO2->setText(QString::number(co2) + " ppm");

    // 构造上报JSON
    QJsonObject rootObj;
    QJsonArray servicesArray;
    QJsonObject serviceObj;
    QJsonObject propertiesObj;

    propertiesObj.insert("SHT30_T", temp);
    propertiesObj.insert("SHT30_H", humi);
    propertiesObj.insert("BH1750", light);
    propertiesObj.insert("SOIL", soil);
    propertiesObj.insert("SGP30", co2);
    propertiesObj.insert("LED_SW", ledSw);
    propertiesObj.insert("MOTOR_SW", motorSw);
    propertiesObj.insert("mode_type", modeType);
    propertiesObj.insert("SOIL_MIN", soilMin);
    propertiesObj.insert("FEN_MOTOR_SW", fanSw);

    serviceObj.insert("service_id", "stm32");
    serviceObj.insert("properties", propertiesObj);
    servicesArray.append(serviceObj);
    rootObj.insert("services", servicesArray);

    QJsonDocument doc(rootObj);
    QString publishMessage = doc.toJson(QJsonDocument::Compact);

    // 发布消息
    QString publishTopic = ui->lineEdit_PublishTopic->text();
    m_mqttClient->publish(publishTopic, publishMessage.toUtf8(), 1);

    qDebug() << "Published data:" << publishMessage;
}

void Widget::onMotorOnClicked()
{
    sendCommand("MOTOR_SW", true);
    ui->label_MotorStatus->setText("开启");
    ui->label_MotorStatus->setStyleSheet("color: green");
}

void Widget::onMotorOffClicked()
{
    sendCommand("MOTOR_SW", false);
    ui->label_MotorStatus->setText("关闭");
    ui->label_MotorStatus->setStyleSheet("color: red");
}

void Widget::onLedOnClicked()
{
    sendCommand("LED_SW", true);
    ui->label_LedStatus->setText("开启");
    ui->label_LedStatus->setStyleSheet("color: green");
}

void Widget::onLedOffClicked()
{
    sendCommand("LED_SW", false);
    ui->label_LedStatus->setText("关闭");
    ui->label_LedStatus->setStyleSheet("color: red");
}

void Widget::onFanOnClicked()
{
    sendCommand("FEN_MOTOR_SW", true);
    ui->label_FanStatus->setText("开启");
    ui->label_FanStatus->setStyleSheet("color: green");
}

void Widget::onFanOffClicked()
{
    sendCommand("FEN_MOTOR_SW", false);
    ui->label_FanStatus->setText("关闭");
    ui->label_FanStatus->setStyleSheet("color: red");
}

void Widget::onModeAutoClicked()
{
    sendCommand("mode_type", true);
    ui->label_ModeStatus->setText("自动模式");
    ui->label_ModeStatus->setStyleSheet("color: blue");
}

void Widget::onModeManualClicked()
{
    sendCommand("mode_type", false);
    ui->label_ModeStatus->setText("手动模式");
    ui->label_ModeStatus->setStyleSheet("color: orange");
}

void Widget::onSetSoilMinClicked()
{
    int value = ui->lineEdit_SoilMin->text().toInt();
    if (value < 10 || value > 80) {
        QMessageBox::warning(this, "警告", "土壤湿度阈值范围应在10~80之间");
        return;
    }
    sendCommand("SOIL_MIN", value);
}

void Widget::sendCommand(const QString &commandName, const QVariant &value)
{
    if (!m_connected) {
        QMessageBox::warning(this, "提示", "MQTT未连接，请先连接服务器");
        return;
    }

    // 构造指令下发JSON（符合华为云平台指令格式）
    QJsonObject rootObj;
    QJsonObject parasObj;

    // 根据命令类型决定参数格式
    if (value.type() == QVariant::Bool) {
        parasObj.insert("value", value.toBool());
    } else if (value.type() == QVariant::Int) {
        parasObj.insert("value", value.toInt());
    } else if (value.type() == QVariant::Double) {
        parasObj.insert("value", value.toDouble());
    } else {
        parasObj.insert("value", value.toString());
    }

    rootObj.insert("command_name", commandName);
    rootObj.insert("paras", parasObj);

    QJsonDocument doc(rootObj);
    QString commandMessage = doc.toJson(QJsonDocument::Compact);

    // 通过下行Topic发布指令（实际华为云平台是通过平台下发，客户端不需直接发布指令）
    // 这里为了演示，使用发布Topic发送，实际APP应通过华为云API下发命令
    // 此处改为通过订阅Topic直接发送模拟指令（便于测试）
    QString subscribeTopic = ui->lineEdit_SubscribeTopic->text();
    m_mqttClient->publish(subscribeTopic, commandMessage.toUtf8(), 1);

    qDebug() << "Send command:" << commandMessage;
}

对应的头文件widget.h：

// widget.h
#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QMqttClient>
#include <QTimer>
#include <QVariant>

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

private slots:
    void onConnectButtonClicked();
    void onMqttStateChanged(QMqttClient::ClientState state);
    void onMqttMessageReceived(const QByteArray &message, const QMqttTopicName &topic);
    void onPingResponseReceived();
    void onRefreshButtonClicked();
    void onPublishDataTimer();
    void onMotorOnClicked();
    void onMotorOffClicked();
    void onLedOnClicked();
    void onLedOffClicked();
    void onFanOnClicked();
    void onFanOffClicked();
    void onModeAutoClicked();
    void onModeManualClicked();
    void onSetSoilMinClicked();

private:
    void setControlsEnabled(bool enabled);
    void sendCommand(const QString &commandName, const QVariant &value);

private:
    Ui::Widget *ui;
    QMqttClient *m_mqttClient;
    QTimer *m_timer;
    bool m_connected;
};
#endif // WIDGET_H

使用说明：

1. 1. 在Qt Creator中创建项目时，需要在

.pro

1. 文件中添加MQTT模块：

QT += mqtt

1. 2. UI界面需要包含对应的控件（标签、按钮、行编辑框等），控件名称与代码中

ui->

访问的名称对应3. 该代码实现了完整的MQTT连接、订阅、发布、数据定时上报和远程控制功能

四、搭建ESP32开发环境

4.1 安装VSCode代码编辑器

【1】下载软件包

下载地址: https://code.visualstudio.com/

安装包下载之后，直接鼠标双击运行。

【2】开始安装

接受协议继续安装。

选择一下安装路径。

浏览路径。

安装。

【4】配置中文语言

安装完成。打开的页面。

软件安装之后下面设置 Visual Studio 支持中文语言

首先打开 Visual Studio 软件， 再按下F1 或者 Shift + Ctrl + P：

然后在命令行输入 Configure Display Language

选择安装语言选项。

安装之后右下角有提示重启，点击重启即可。

【5】配置主题颜色

修改vscode的颜色主题

下面介绍更改颜色vscode的内置颜色主题方法。

4.2 安装ESP-IDE环境

官方教程：https://docs.espressif.com/projects/esp-idf/zh_CN/v5.1.5/esp32/get-started/index.html

【1】安装IDE环境

链接：https://dl.espressif.cn/dl/esp-idf/

下载成功后，双击开始安装。 安装的路径可以选择D盘，毕竟占用的空间还是比较大的。 比如，在D盘创建一个文件夹。ESP_IDF 后面安装时，路径就选择这文件夹。

注意：安装的时候要关闭VSCODE软件。

【2】VSCODE安装插件

官方教程：https://docs.espressif.com/projects/vscode-esp-idf-extension/zh_CN/latest/index.html

上一步安装完毕之后。 再打开VSCODE软件。

打开扩展商店，搜索espressif,然后看到第一个ESP-IDF ，点击右边出现的安装。

安装成功之后，打开命令行面板。

然后 输入 configure esp-idf extension。

选择下面的弹出来的选项。

选择用户安装的路径。

选择识别出来的安装路径。

接下来就可以正常愉快的开发代码了。

4.3 快速新建工程

【1】快速新建项目

每次打开VSCODE想要快速新建ESP32的项目。

直接在命令行窗口。输入ESP-IDF:新建项目。

选择新建项目。

选择新建工程。

配置工程的名称，存储工程的路径（不能出现中文），芯片的型号，调试方式。串口端口（如果当前没有接开发板大电脑里就不用管）。 选好了，点击右下角的选项创建工程。

创建成功之后，下面就可以选择创建工程的例程模版。

在第一个选项点击后会弹出两个选项可以选择，是使用扩展例程（ExtenSion）还是使用官方IDF的例程（ESP-IDF）。

当前选择 【ExtenSion】下的 【template-app】进行工程创建。(还有很多的例程，大家可以自行尝试)

点击右边的按钮，创建模版工程。

创建完成之后，右下角会提示【工程已经创建完毕，是否用新窗口打开工程？】点击Yes则会出现打开一个VSCode窗口，点击NO则会在该界面显示工程。

打开工程可以写一段打印函数。测试工程运行情况。

然后把ESP32通过串口插到电脑USB口上。

在下面可以选择下载方式，选择串口，然后选择串口的端口。

点击编译下载。程序运行之后会打印信息到终端。

第一次编译比较慢，需要多等一下。 后面的编译就比较快了。

成功之后，可以看到串口上的数据打印。

到此。工程就搭建好了。

【2】修改配置

在连接成功的情况下，点击设置按钮。

修改FLASH大小
在上方的搜索栏中输入【flash】，根据开发板板载的FLASH大小选择对应的FLASH大小。开发板板载W25Q64是8M大小。

修改系统时钟
在上方的搜索栏中输入【cpu】，根据情况选择CPU频率，这里选择的是最高频率240MHz。

修改完成之后点击【保存】键才会生效。

4.4 编程控制LED灯

【1】点亮LED灯

下面学习如何控制IO口，完成LED灯的控制。

为了模块化编程。下面需要新建一个目录，下面存储我们后续编写的外设硬件的代码。

新建一个hardware 文件夹。

然后在hardware 文件夹下面新建.c文件和.h文件。

新建2个文件。led.c和led.h。方便存储LED灯相关的源代码和函数声明。

在led.c的文件里写上代码：

#include "led.h"

//配置输出寄存器
#define GPIO_OUTPUT_PIN_SEL  (1ULL<<LED_PIN)

/**
 * @函数说明        LED的初始化
 *
 */
void LedGpioConfig(void)
{
    gpio_config_t gpio_init_struct = {0};

    //配置IO为通用IO
    esp_rom_gpio_pad_select_gpio(LED_PIN);

    gpio_init_struct.intr_type = GPIO_INTR_DISABLE;             //不使用中断
    gpio_init_struct.mode = GPIO_MODE_OUTPUT;                   //输出模式
    gpio_init_struct.pull_up_en = GPIO_PULLUP_ENABLE;           //使能上拉模式
    gpio_init_struct.pull_down_en = GPIO_PULLDOWN_DISABLE;      //失能下拉模式
    gpio_init_struct.pin_bit_mask = GPIO_OUTPUT_PIN_SEL;        //使用GPIO9输出寄存器

    //将以上参数配置到引脚
    gpio_config( &gpio_init_struct );

    //设置引脚输出高电平，默认不让LED亮
    gpio_set_level(LED_PIN, 1);
}

/**
 * @函数说明        设置LED亮
 *
 */
void LedOn(void)
{
    gpio_set_level(LED_PIN, 0);
}

/**
 * @函数说明        设置LED灭
 *
 */
void LedOff(void)
{
    gpio_set_level(LED_PIN, 1);
}

在led.h文件里写上代码：

#ifndef _BSP_LED_H_
#define _BSP_LED_H_

#include "driver/gpio.h"

//设置LED引脚
#define  LED_PIN  48

/**
 * @brief   LED初始化
 *
 */
void LedGpioConfig(void);

/**
 * @brief       设置LED亮
 *
 */
void LedOn(void);

/**
 * @brief       设置LED灭
 *
 */
void LedOff(void);
#endif

然后修改CMakeLists.txt 文件。 这个文件是配置头文件和源文件的路径的。  需要配置了之后，编译器才知道.c和.h文件在什么地方。

idf_component_register(SRCS "main.c"
                            "hardware/led.c"
                    INCLUDE_DIRS "."
                                 "./hardware")

最后编写main.c代码，在main.c文件里写上点灯的调用。

#include <stdio.h>
#include "hardware/led.h"

void app_main(void)
{
    //LED初始化
    LedGpioConfig();

    //设置LED点亮
    LedOn();

}

写完代码之后，点击构建烧录，代码就下载进去了。

下载成功之后，可以看到灯就已经亮了。 绿色的小灯就是点亮的LED灯。

【2】升级成闪光灯

要做成闪光灯就需要用到延时函数。

在ESP-IDF 中，可以使用下面3种方式来实现延时：

1. vTaskDelay() 函数

这个函数会让当前的任务挂起指定的时间。例如，vTaskDelay(1000 / portTICK_PERIOD_MS) 会让当前任务挂起 1 秒钟，等待一个系统时钟周期。

2. usleep() 函数

这个函数可以以微秒为单位精准延时。例如， usleep(1000000) 会让任务休眠 1 秒钟。

3. esp_rom_delay_us()函数

可以进行微秒级延时。

这里面的void vTaskDelay( const TickType_t xTicksToDelay ) 函数，是将一个任务延迟给定的xTicksToDelay数。任务被阻止的实际时间取决于tick rate。常数portTICK_PERIOD_MS可以用来从tick rate计算实时时间，分辨率为一个tick 周期。至于一个时钟节拍数是1ms，2ms，还是10ms，取决于configTICK_RATE_Hz，即 cONFI6_FREERTOS_HZ。CONFIG_FREERTOS_HZ在sdkconfig中定义，默认是100Hz。则一个时钟节拍数是10ms。

我们可以看一下系统默认的配置。

这个配置在 FreeRTOSConfig.h 文件中：

#define configTICK_RATE_HZ        100

简单来说：

configTICK_RATE_HZ 定义了 FreeRTOS 的系统时钟节拍频率，表示：

系统每秒钟产生 100 个时钟节拍（tick）

每个时钟节拍的间隔 = 10ms

 (1000ms ÷ 100 = 10ms)

在main.c里编写LED闪烁的代码。

#include <stdio.h>
#include "hardware/led.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

/**
 * @函数说明        毫秒延时函数
 * @参数 ms        延时的毫秒数
 * @注意           最小延时为1个FreeRTOS tick
 */
void delay_ms(uint32_t ms)
{
    if (ms == 0) return;
    
    TickType_t ticks = (ms + portTICK_PERIOD_MS - 1) / portTICK_PERIOD_MS;
    vTaskDelay(ticks > 0 ? ticks : 1);
}

void app_main(void)
{
    int state=0;
    //LED初始化
    LedGpioConfig();

     while(1) {
        state=!state;
        delay_ms(1000);  // 延时1秒
        if(state)
        {
            LedOn();
        }
        else
        {
            LedOff();
        }
    }
}

然后编译烧录进去。

就可以看到LED灯在闪烁了。

五、ESP32-代码设计

5.1 硬件连线

（1）ESP32-S3-R8N8主控芯片电源接线：ESP32-S3开发板的5V引脚接外部5V 2A电源的正极，GND引脚接电源的负极，为整个系统提供工作电源。

（2）SHT30温湿度传感器接线：SHT30的VCC引脚接ESP32-S3的3.3V输出引脚，GND引脚接ESP32-S3的GND引脚，SCL引脚接ESP32-S3的I2C时钟引脚（GPIO_9），SDA引脚接ESP32-S3的I2C数据引脚（GPIO_8）。

（3）BH1750光照强度传感器接线：BH1750的VCC引脚接ESP32-S3的3.3V输出引脚，GND引脚接ESP32-S3的GND引脚，SCL引脚接ESP32-S3的I2C时钟引脚（GPIO_9），SDA引脚接ESP32-S3的I2C数据引脚（GPIO_8），与SHT30传感器共用I2C总线。

（4）SGP30二氧化碳传感器接线：SGP30的VCC引脚接ESP32-S3的3.3V输出引脚，GND引脚接ESP32-S3的GND引脚，SCL引脚接ESP32-S3的I2C时钟引脚（GPIO_9），SDA引脚接ESP32-S3的I2C数据引脚（GPIO_8），与SHT30和BH1750共用I2C总线。

（5）土壤湿度传感器接线：土壤湿度传感器的VCC引脚接ESP32-S3的3.3V输出引脚，GND引脚接ESP32-S3的GND引脚，AO（模拟输出）引脚接ESP32-S3的ADC输入引脚（GPIO_4），用于读取土壤湿度的模拟电压值。

（6）1.44寸SPI协议LCD显示屏接线：LCD显示屏的VCC引脚接ESP32-S3的3.3V输出引脚，GND引脚接ESP32-S3的GND引脚，SCL（时钟线）引脚接ESP32-S3的GPIO_14，SDA（数据线）引脚接ESP32-S3的GPIO_13，RES（复位）引脚接ESP32-S3的GPIO_12，DC（数据/命令选择）引脚接ESP32-S3的GPIO_11，CS（片选）引脚接ESP32-S3的GPIO_10。

（7）Air724 4G模块接线：Air724模块的VCC引脚接ESP32-S3的5V输出引脚（或外部5V电源），GND引脚接ESP32-S3的GND引脚，TXD引脚接ESP32-S3的UART接收引脚（GPIO_17），RXD引脚接ESP32-S3的UART发送引脚（GPIO_16），模块的PWR_KEY引脚通过10K电阻上拉至3.3V并连接ESP32-S3的GPIO_18用于控制模块开机。

（8）灌溉电磁阀继电器模块接线：继电器模块的VCC引脚接ESP32-S3的5V输出引脚，GND引脚接ESP32-S3的GND引脚，IN（控制信号）引脚接ESP32-S3的GPIO_5，继电器COM端接外部5V电源正极，NO（常开端）接电磁阀正极，电磁阀负极接电源负极，通过继电器控制电磁阀的通断实现灌溉喷洒。

（9）补光灯LED继电器模块接线：继电器模块的VCC引脚接ESP32-S3的5V输出引脚，GND引脚接ESP32-S3的GND引脚，IN（控制信号）引脚接ESP32-S3的GPIO_6，继电器COM端接外部5V电源正极，NO（常开端）接白色LED补光灯正极，LED负极接电源负极，通过继电器控制补光灯的开关。

（10）通风风扇继电器模块接线：继电器模块的VCC引脚接ESP32-S3的5V输出引脚，GND引脚接ESP32-S3的GND引脚，IN（控制信号）引脚接ESP32-S3的GPIO_7，继电器COM端接外部5V电源正极，NO（常开端）接5V小风扇正极，风扇负极接电源负极，通过继电器控制通风风扇的开关。

（11）本地控制按钮接线：三个独立按键的一端分别接ESP32-S3的GPIO_1、GPIO_2、GPIO_3引脚，另一端共同接GND，按键未按下时通过ESP32-S3内部上拉电阻保持高电平，按下时拉低电平实现按键检测。其中GPIO_1用于补水控制按钮、GPIO_2用于补光灯控制按钮、GPIO_3用于运行模式切换按钮。

（12）系统整体电源分配：外部5V 2A电源接入系统控制板后，一路直接为ESP32-S3开发板供电，一路为4G模块提供工作电源，一路为三个继电器模块提供线圈驱动电源，一路经过板载降压芯片转换为3.3V为SHT30、BH1750、SGP30、土壤湿度传感器及LCD显示屏供电，各模块GND端统一连接到电源负极形成共地系统。

5.2 硬件组装过程

【项目复刻_PCB焊接过程演示】 https://www.bilibili.com/video/BV1FmPVzYEVx/?share_source=copy_web&vd_source=347136f3e32fe297fc17177194ce0a8b

5.3 工程截图

5.4 程序下载

5.5 程序正常运行效果

5.6 取模软件的使用

显示屏上会显示中文，字母，数字等数据，可以使用下面的取模软件进行取模设置。

[软件就在资料包里的软件工具目录下]

打开软件之后：

5.7 工程代码完整讲解

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "esp_system.h"
#include "esp_log.h"
#include "esp_wifi.h"
#include "nvs_flash.h"
#include "driver/gpio.h"
#include "driver/adc.h"
#include "driver/uart.h"
#include "driver/spi_master.h"
#include "driver/i2c.h"
#include "esp_adc_cal.h"
#include "esp_timer.h"
#include "cJSON.h"

// 传感器头文件
#include "sht30.h"
#include "bh1750.h"
#include "sgp30.h"
#include "lcd_st7789.h"

// 4G模块通信头文件
#include "air724.h"

// ===================== 引脚定义 =====================
// I2C引脚 (SHT30, BH1750, SGP30共用)
#define I2C_MASTER_SCL_IO           GPIO_NUM_9
#define I2C_MASTER_SDA_IO           GPIO_NUM_8
#define I2C_MASTER_FREQ_HZ          100000

// SPI LCD引脚
#define LCD_SPI_HOST                SPI2_HOST
#define LCD_SCLK_PIN                GPIO_NUM_14
#define LCD_SDA_PIN                 GPIO_NUM_13
#define LCD_RES_PIN                 GPIO_NUM_12
#define LCD_DC_PIN                  GPIO_NUM_11
#define LCD_CS_PIN                  GPIO_NUM_10

// ADC土壤湿度引脚
#define SOIL_ADC_CHANNEL            ADC_CHANNEL_4   // GPIO4
#define SOIL_ADC_WIDTH              ADC_WIDTH_BIT_12
#define SOIL_ADC_ATTEN              ADC_ATTEN_DB_11

// 继电器控制引脚
#define MOTOR_RELAY_PIN             GPIO_NUM_5      // 灌溉电机继电器
#define LED_RELAY_PIN               GPIO_NUM_6      // 补光灯继电器
#define FAN_RELAY_PIN               GPIO_NUM_7      // 通风风扇继电器

// 按键引脚
#define KEY_MOTOR_PIN               GPIO_NUM_1      // 补水控制按钮
#define KEY_LED_PIN                 GPIO_NUM_2      // 补光灯控制按钮
#define KEY_MODE_PIN                GPIO_NUM_3      // 模式切换按钮

// UART引脚 (Air724 4G模块)
#define UART_4G_PORT                UART_NUM_1
#define UART_4G_TXD                 GPIO_NUM_16
#define UART_4G_RXD                 GPIO_NUM_17
#define UART_4G_PWR_KEY             GPIO_NUM_18

// ===================== 宏定义 =====================
#define SAMPLE_INTERVAL_MS          2000            // 采样间隔2秒
#define MQTT_REPORT_INTERVAL_MS     10000           // MQTT上报间隔10秒
#define DEBOUNCE_TIME_MS            50              // 按键消抖时间50ms

#define SOIL_MIN_DEFAULT            30              // 土壤湿度默认阈值(%)
#define TEMP_FAN_THRESHOLD          30.0            // 风扇开启温度阈值(°C)
#define LIGHT_THRESHOLD             100             // 补光灯开启光照阈值(Lux)

// ===================== 全局变量 =====================
static const char *TAG = "WATERMELON_SYS";

// 传感器数据结构
typedef struct {
    float temperature;          // 环境温度 (°C)
    float humidity;             // 环境湿度 (%)
    float light;                // 光照强度 (Lux)
    float soil_moisture;        // 土壤湿度 (%)
    int co2;                    // 二氧化碳浓度 (ppm)
} sensor_data_t;

// 系统状态结构
typedef struct {
    bool motor_sw;              // 灌溉电机开关
    bool led_sw;                // 补光灯开关
    bool fan_sw;                // 通风风扇开关
    bool mode_type;             // true=自动模式, false=手动模式
    int soil_min;               // 土壤湿度阈值
    bool manual_motor_req;      // 手动补水请求
    bool manual_led_req;        // 手动补光请求
} system_state_t;

sensor_data_t g_sensor_data = {0};
system_state_t g_sys_state = {
    .motor_sw = false,
    .led_sw = false,
    .fan_sw = false,
    .mode_type = true,          // 默认自动模式
    .soil_min = SOIL_MIN_DEFAULT,
    .manual_motor_req = false,
    .manual_led_req = false
};

// 队列句柄
QueueHandle_t g_key_queue = NULL;

// 按键事件结构
typedef struct {
    uint8_t key_id;
    bool pressed;
} key_event_t;

// ADC校准
esp_adc_cal_characteristics_t *g_adc_chars = NULL;

// 任务句柄
TaskHandle_t g_mqtt_task_handle = NULL;

// ===================== 函数声明 =====================
static void init_i2c(void);
static void init_spi_lcd(void);
static void init_adc(void);
static void init_gpio(void);
static void init_uart_4g(void);
static void init_tasks(void);
static void read_all_sensors(sensor_data_t *data);
static float read_soil_moisture(void);
static void update_lcd_display(sensor_data_t *data, system_state_t *state);
static void control_actuators(system_state_t *state);
static void process_auto_mode(sensor_data_t *data, system_state_t *state);
static void key_scan_task(void *pvParameters);
static void sensor_read_task(void *pvParameters);
static void mqtt_task(void *pvParameters);
static void generate_mqtt_payload(char *buffer, size_t size, sensor_data_t *data, system_state_t *state);
static void process_mqtt_command(const char *cmd_json);
static void check_4g_connection(void);

// ===================== I2C初始化 =====================
static void init_i2c(void)
{
    i2c_config_t conf = {
        .mode = I2C_MODE_MASTER,
        .sda_io_num = I2C_MASTER_SDA_IO,
        .scl_io_num = I2C_MASTER_SCL_IO,
        .sda_pullup_en = GPIO_PULLUP_ENABLE,
        .scl_pullup_en = GPIO_PULLUP_ENABLE,
        .master.clk_speed = I2C_MASTER_FREQ_HZ,
    };
    
    i2c_param_config(I2C_NUM_0, &conf);
    i2c_driver_install(I2C_NUM_0, conf.mode, 0, 0, 0);
    ESP_LOGI(TAG, "I2C initialized");
}

// ===================== SPI LCD初始化 =====================
static void init_spi_lcd(void)
{
    spi_bus_config_t bus_cfg = {
        .miso_io_num = -1,
        .mosi_io_num = LCD_SDA_PIN,
        .sclk_io_num = LCD_SCLK_PIN,
        .quadwp_io_num = -1,
        .quadhd_io_num = -1,
        .max_transfer_sz = 4096,
    };
    
    spi_bus_initialize(LCD_SPI_HOST, &bus_cfg, SPI_DMA_CH_AUTO);
    
    lcd_st7789_config_t lcd_cfg = {
        .spi_host = LCD_SPI_HOST,
        .cs_io = LCD_CS_PIN,
        .dc_io = LCD_DC_PIN,
        .rst_io = LCD_RES_PIN,
        .width = 128,
        .height = 128,
    };
    
    lcd_st7789_init(&lcd_cfg);
    lcd_st7789_clear(0x0000);
    ESP_LOGI(TAG, "LCD initialized");
}

// ===================== ADC初始化 =====================
static void init_adc(void)
{
    adc1_config_width(SOIL_ADC_WIDTH);
    adc1_config_channel_atten(SOIL_ADC_CHANNEL, SOIL_ADC_ATTEN);
    
    g_adc_chars = calloc(1, sizeof(esp_adc_cal_characteristics_t));
    esp_adc_cal_characterize(ADC_UNIT_1, SOIL_ADC_ATTEN, SOIL_ADC_WIDTH, 1100, g_adc_chars);
    ESP_LOGI(TAG, "ADC initialized");
}

// ===================== GPIO初始化 =====================
static void init_gpio(void)
{
    // 继电器输出引脚
    gpio_config_t out_conf = {
        .pin_bit_mask = (1ULL << MOTOR_RELAY_PIN) | 
                        (1ULL << LED_RELAY_PIN) | 
                        (1ULL << FAN_RELAY_PIN),
        .mode = GPIO_MODE_OUTPUT,
        .pull_up_en = GPIO_PULLUP_DISABLE,
        .pull_down_en = GPIO_PULLDOWN_DISABLE,
        .intr_type = GPIO_INTR_DISABLE,
    };
    gpio_config(&out_conf);
    
    // 初始状态：所有继电器关闭
    gpio_set_level(MOTOR_RELAY_PIN, 0);
    gpio_set_level(LED_RELAY_PIN, 0);
    gpio_set_level(FAN_RELAY_PIN, 0);
    
    // 按键输入引脚 (使用内部上拉)
    gpio_config_t in_conf = {
        .pin_bit_mask = (1ULL << KEY_MOTOR_PIN) | 
                        (1ULL << KEY_LED_PIN) | 
                        (1ULL << KEY_MODE_PIN),
        .mode = GPIO_MODE_INPUT,
        .pull_up_en = GPIO_PULLUP_ENABLE,
        .pull_down_en = GPIO_PULLDOWN_DISABLE,
        .intr_type = GPIO_INTR_DISABLE,
    };
    gpio_config(&in_conf);
    
    // 4G模块电源控制引脚
    gpio_config_t pwr_conf = {
        .pin_bit_mask = (1ULL << UART_4G_PWR_KEY),
        .mode = GPIO_MODE_OUTPUT,
        .pull_up_en = GPIO_PULLUP_DISABLE,
        .pull_down_en = GPIO_PULLDOWN_DISABLE,
        .intr_type = GPIO_INTR_DISABLE,
    };
    gpio_config(&pwr_conf);
    
    // 默认拉低，不给4G模块供电
    gpio_set_level(UART_4G_PWR_KEY, 0);
    
    ESP_LOGI(TAG, "GPIO initialized");
}

// ===================== UART初始化 (4G模块) =====================
static void init_uart_4g(void)
{
    uart_config_t uart_cfg = {
        .baud_rate = 115200,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
        .source_clk = UART_SCLK_APB,
    };
    
    uart_param_config(UART_4G_PORT, &uart_cfg);
    uart_set_pin(UART_4G_PORT, UART_4G_TXD, UART_4G_RXD, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
    uart_driver_install(UART_4G_PORT, 1024, 1024, 0, NULL, 0);
    
    ESP_LOGI(TAG, "UART for 4G initialized");
    
    // 初始化Air724模块
    air724_init(UART_4G_PORT);
}

// ===================== 读取土壤湿度 =====================
static float read_soil_moisture(void)
{
    uint32_t adc_value = adc1_get_raw(SOIL_ADC_CHANNEL);
    
    // 转换为电压(mV)
    uint32_t voltage = esp_adc_cal_raw_to_voltage(adc_value, g_adc_chars);
    
    // 转换为百分比 (电压范围: 0~3300mV)
    // 干燥时电压较高(约2500mV)，湿润时电压较低(约500mV)
    float percent = 100.0 - ((voltage - 100) / 32.0);
    if (percent < 0) percent = 0;
    if (percent > 100) percent = 100;
    
    return percent;
}

// ===================== 读取所有传感器 =====================
static void read_all_sensors(sensor_data_t *data)
{
    // 读取SHT30温湿度
    sht30_read_temperature_humidity(&data->temperature, &data->humidity);
    
    // 读取BH1750光照强度
    data->light = bh1750_read_light();
    
    // 读取土壤湿度
    data->soil_moisture = read_soil_moisture();
    
    // 读取SGP30二氧化碳
    data->co2 = sgp30_read_co2();
    
    ESP_LOGD(TAG, "Temp: %.1f°C, Humi: %.1f%%, Light: %.1fLux, Soil: %.1f%%, CO2: %dppm",
             data->temperature, data->humidity, data->light, data->soil_moisture, data->co2);
}

// ===================== 更新LCD显示 =====================
static void update_lcd_display(sensor_data_t *data, system_state_t *state)
{
    char display_buf[128];
    
    // 清屏
    lcd_st7789_clear(0x0000);
    
    // 显示温度
    sprintf(display_buf, "T:%.1fC", data->temperature);
    lcd_st7789_draw_string(display_buf, 0, 0, 0xFFFF, 0x0000);
    
    // 显示湿度
    sprintf(display_buf, "H:%.1f%%", data->humidity);
    lcd_st7789_draw_string(display_buf, 0, 16, 0xFFFF, 0x0000);
    
    // 显示光照
    sprintf(display_buf, "Lux:%.0f", data->light);
    lcd_st7789_draw_string(display_buf, 0, 32, 0xFFFF, 0x0000);
    
    // 显示土壤湿度
    sprintf(display_buf, "Soil:%.1f%%", data->soil_moisture);
    lcd_st7789_draw_string(display_buf, 0, 48, 0xFFFF, 0x0000);
    
    // 显示CO2
    sprintf(display_buf, "CO2:%dppm", data->co2);
    lcd_st7789_draw_string(display_buf, 0, 64, 0xFFFF, 0x0000);
    
    // 显示模式
    sprintf(display_buf, "Mode:%s", state->mode_type ? "Auto" : "Manual");
    lcd_st7789_draw_string(display_buf, 0, 80, 0xFFFF, 0x0000);
    
    // 显示电机状态
    sprintf(display_buf, "Motor:%s", state->motor_sw ? "ON" : "OFF");
    lcd_st7789_draw_string(display_buf, 0, 96, 0xFFFF, 0x0000);
    
    // 显示LED状态
    sprintf(display_buf, "LED:%s", state->led_sw ? "ON" : "OFF");
    lcd_st7789_draw_string(display_buf, 0, 112, 0xFFFF, 0x0000);
}

// ===================== 执行器控制 =====================
static void control_actuators(system_state_t *state)
{
    gpio_set_level(MOTOR_RELAY_PIN, state->motor_sw ? 1 : 0);
    gpio_set_level(LED_RELAY_PIN, state->led_sw ? 1 : 0);
    gpio_set_level(FAN_RELAY_PIN, state->fan_sw ? 1 : 0);
}

// ===================== 自动模式处理 =====================
static void process_auto_mode(sensor_data_t *data, system_state_t *state)
{
    if (!state->mode_type) {
        return; // 非自动模式，不处理
    }
    
    // 1. 土壤湿度自动控制
    if (data->soil_moisture < state->soil_min) {
        state->motor_sw = true;
        ESP_LOGI(TAG, "Auto: Soil moisture low (%.1f%% < %d%%), motor ON", 
                 data->soil_moisture, state->soil_min);
    } else {
        state->motor_sw = false;
    }
    
    // 2. 补光灯自动控制
    if (data->light < LIGHT_THRESHOLD) {
        state->led_sw = true;
        ESP_LOGI(TAG, "Auto: Light low (%.1fLux < %dLux), LED ON", 
                 data->light, LIGHT_THRESHOLD);
    } else {
        state->led_sw = false;
    }
    
    // 3. 通风风扇自动控制
    if (data->temperature > TEMP_FAN_THRESHOLD) {
        state->fan_sw = true;
        ESP_LOGI(TAG, "Auto: Temp high (%.1f°C > %.1f°C), fan ON", 
                 data->temperature, TEMP_FAN_THRESHOLD);
    } else {
        state->fan_sw = false;
    }
}

// ===================== 按键扫描任务 =====================
static void key_scan_task(void *pvParameters)
{
    uint8_t last_motor_key = 1;
    uint8_t last_led_key = 1;
    uint8_t last_mode_key = 1;
    
    key_event_t key_evt;
    
    while (1) {
        uint8_t motor_key = gpio_get_level(KEY_MOTOR_PIN);
        uint8_t led_key = gpio_get_level(KEY_LED_PIN);
        uint8_t mode_key = gpio_get_level(KEY_MODE_PIN);
        
        // 检测按键按下 (电平从高到低变化)
        if (last_motor_key == 1 && motor_key == 0) {
            key_evt.key_id = 1;
            key_evt.pressed = true;
            xQueueSend(g_key_queue, &key_evt, 0);
            ESP_LOGI(TAG, "Motor key pressed");
        }
        
        if (last_led_key == 1 && led_key == 0) {
            key_evt.key_id = 2;
            key_evt.pressed = true;
            xQueueSend(g_key_queue, &key_evt, 0);
            ESP_LOGI(TAG, "LED key pressed");
        }
        
        if (last_mode_key == 1 && mode_key == 0) {
            key_evt.key_id = 3;
            key_evt.pressed = true;
            xQueueSend(g_key_queue, &key_evt, 0);
            ESP_LOGI(TAG, "Mode key pressed");
        }
        
        last_motor_key = motor_key;
        last_led_key = led_key;
        last_mode_key = mode_key;
        
        vTaskDelay(pdMS_TO_TICKS(DEBOUNCE_TIME_MS));
    }
}

// ===================== 传感器读取任务 =====================
static void sensor_read_task(void *pvParameters)
{
    TickType_t last_wake_time = xTaskGetTickCount();
    
    while (1) {
        // 读取所有传感器
        read_all_sensors(&g_sensor_data);
        
        // 自动模式处理
        process_auto_mode(&g_sensor_data, &g_sys_state);
        
        // 执行器控制
        control_actuators(&g_sys_state);
        
        // 更新LCD显示
        update_lcd_display(&g_sensor_data, &g_sys_state);
        
        // 处理按键队列中的事件
        key_event_t key_evt;
        while (xQueueReceive(g_key_queue, &key_evt, 0) == pdTRUE) {
            if (key_evt.pressed) {
                // 手动模式下才响应按键
                if (!g_sys_state.mode_type) {
                    switch (key_evt.key_id) {
                        case 1: // 补水按钮
                            g_sys_state.motor_sw = !g_sys_state.motor_sw;
                            ESP_LOGI(TAG, "Manual: Motor toggled to %s", 
                                     g_sys_state.motor_sw ? "ON" : "OFF");
                            break;
                        case 2: // 补光灯按钮
                            g_sys_state.led_sw = !g_sys_state.led_sw;
                            ESP_LOGI(TAG, "Manual: LED toggled to %s", 
                                     g_sys_state.led_sw ? "ON" : "OFF");
                            break;
                        case 3: // 模式切换按钮
                            g_sys_state.mode_type = !g_sys_state.mode_type;
                            ESP_LOGI(TAG, "Mode switched to: %s", 
                                     g_sys_state.mode_type ? "Auto" : "Manual");
                            break;
                        default:
                            break;
                    }
                } else {
                    // 自动模式下，模式按键仍然可以切换
                    if (key_evt.key_id == 3) {
                        g_sys_state.mode_type = !g_sys_state.mode_type;
                        ESP_LOGI(TAG, "Mode switched to: %s", 
                                 g_sys_state.mode_type ? "Auto" : "Manual");
                    }
                }
            }
        }
        
        vTaskDelayUntil(&last_wake_time, pdMS_TO_TICKS(SAMPLE_INTERVAL_MS));
    }
}

// ===================== 生成MQTT载荷 =====================
static void generate_mqtt_payload(char *buffer, size_t size, sensor_data_t *data, system_state_t *state)
{
    cJSON *root = cJSON_CreateObject();
    cJSON *services = cJSON_CreateArray();
    cJSON *service = cJSON_CreateObject();
    cJSON *properties = cJSON_CreateObject();
    
    // 添加属性
    cJSON_AddNumberToObject(properties, "SHT30_T", data->temperature);
    cJSON_AddNumberToObject(properties, "SHT30_H", data->humidity);
    cJSON_AddNumberToObject(properties, "BH1750", data->light);
    cJSON_AddNumberToObject(properties, "SOIL", data->soil_moisture);
    cJSON_AddNumberToObject(properties, "SGP30", data->co2);
    cJSON_AddBoolToObject(properties, "LED_SW", state->led_sw);
    cJSON_AddBoolToObject(properties, "MOTOR_SW", state->motor_sw);
    cJSON_AddBoolToObject(properties, "mode_type", state->mode_type);
    cJSON_AddNumberToObject(properties, "SOIL_MIN", state->soil_min);
    cJSON_AddBoolToObject(properties, "FEN_MOTOR_SW", state->fan_sw);
    
    cJSON_AddStringToObject(service, "service_id", "stm32");
    cJSON_AddItemToObject(service, "properties", properties);
    cJSON_AddItemToArray(services, service);
    cJSON_AddItemToObject(root, "services", services);
    
    char *json_str = cJSON_PrintUnformatted(root);
    strncpy(buffer, json_str, size - 1);
    buffer[size - 1] = '';
    
    free(json_str);
    cJSON_Delete(root);
}

// ===================== 处理MQTT下行命令 =====================
static void process_mqtt_command(const char *cmd_json)
{
    cJSON *root = cJSON_Parse(cmd_json);
    if (root == NULL) {
        ESP_LOGE(TAG, "Failed to parse MQTT command");
        return;
    }
    
    cJSON *cmd_name = cJSON_GetObjectItem(root, "command_name");
    cJSON *paras = cJSON_GetObjectItem(root, "paras");
    
    if (cmd_name && paras) {
        cJSON *value = cJSON_GetObjectItem(paras, "value");
        
        if (strcmp(cmd_name->valuestring, "MOTOR_SW") == 0 && value) {
            // 手动模式下才能通过远程控制
            if (!g_sys_state.mode_type) {
                g_sys_state.motor_sw = value->valueint != 0;
                ESP_LOGI(TAG, "Remote: Motor set to %s", g_sys_state.motor_sw ? "ON" : "OFF");
            } else {
                ESP_LOGW(TAG, "Remote control ignored: System in auto mode");
            }
        } else if (strcmp(cmd_name->valuestring, "LED_SW") == 0 && value) {
            if (!g_sys_state.mode_type) {
                g_sys_state.led_sw = value->valueint != 0;
                ESP_LOGI(TAG, "Remote: LED set to %s", g_sys_state.led_sw ? "ON" : "OFF");
            } else {
                ESP_LOGW(TAG, "Remote control ignored: System in auto mode");
            }
        } else if (strcmp(cmd_name->valuestring, "FEN_MOTOR_SW") == 0 && value) {
            if (!g_sys_state.mode_type) {
                g_sys_state.fan_sw = value->valueint != 0;
                ESP_LOGI(TAG, "Remote: Fan set to %s", g_sys_state.fan_sw ? "ON" : "OFF");
            } else {
                ESP_LOGW(TAG, "Remote control ignored: System in auto mode");
            }
        } else if (strcmp(cmd_name->valuestring, "mode_type") == 0 && value) {
            g_sys_state.mode_type = value->valueint != 0;
            ESP_LOGI(TAG, "Remote: Mode set to %s", g_sys_state.mode_type ? "Auto" : "Manual");
        } else if (strcmp(cmd_name->valuestring, "SOIL_MIN") == 0 && value) {
            g_sys_state.soil_min = value->valueint;
            ESP_LOGI(TAG, "Remote: Soil min threshold set to %d", g_sys_state.soil_min);
        }
    }
    
    cJSON_Delete(root);
}

// ===================== MQTT任务 =====================
static void mqtt_task(void *pvParameters)
{
    char publish_topic[128];
    char subscribe_topic[128];
    char payload[512];
    char recv_buf[512];
    int recv_len;
    
    // MQTT配置
    const char *client_id = "67c7dff98e04aa0690ba6341_dev1_0_0_2025030505";
    const char *username = "67c7dff98e04aa0690ba6341_dev1";
    const char *password = "b3894902a6e1ff3571f2f93363aa1019618853f64b78faf09af2afd3561fec67";
    
    snprintf(publish_topic, sizeof(publish_topic), 
             "$oc/devices/67c7dff98e04aa0690ba6341_dev1/sys/properties/report");
    snprintf(subscribe_topic, sizeof(subscribe_topic), 
             "$oc/devices/67c7dff98e04aa0690ba6341_dev1/sys/messages/down");
    
    TickType_t last_publish_time = xTaskGetTickCount();
    bool mqtt_connected = false;
    
    while (1) {
        // 检查4G模块网络状态
        if (!air724_is_network_ready()) {
            ESP_LOGW(TAG, "4G network not ready, waiting...");
            vTaskDelay(pdMS_TO_TICKS(5000));
            continue;
        }
        
        // 连接MQTT
        if (!mqtt_connected) {
            if (air724_mqtt_connect(client_id, username, password, 60)) {
                ESP_LOGI(TAG, "MQTT connected successfully");
                mqtt_connected = true;
                
                // 订阅下行Topic
                if (air724_mqtt_subscribe(subscribe_topic, 1)) {
                    ESP_LOGI(TAG, "Subscribed to: %s", subscribe_topic);
                } else {
                    ESP_LOGE(TAG, "Failed to subscribe");
                }
            } else {
                ESP_LOGE(TAG, "MQTT connection failed, retrying...");
                vTaskDelay(pdMS_TO_TICKS(5000));
                continue;
            }
        }
        
        // 检查MQTT连接状态
        if (!air724_mqtt_is_connected()) {
            ESP_LOGW(TAG, "MQTT disconnected, reconnecting...");
            mqtt_connected = false;
            vTaskDelay(pdMS_TO_TICKS(3000));
            continue;
        }
        
        // 定期发布数据
        if ((xTaskGetTickCount() - last_publish_time) >= pdMS_TO_TICKS(MQTT_REPORT_INTERVAL_MS)) {
            generate_mqtt_payload(payload, sizeof(payload), &g_sensor_data, &g_sys_state);
            
            if (air724_mqtt_publish(publish_topic, payload, 1, 0)) {
                ESP_LOGI(TAG, "Data published: %s", payload);
                last_publish_time = xTaskGetTickCount();
            } else {
                ESP_LOGE(TAG, "Failed to publish data");
            }
        }
        
        // 检查是否有MQTT下行消息
        recv_len = air724_mqtt_receive(recv_buf, sizeof(recv_buf) - 1, 100);
        if (recv_len > 0) {
            recv_buf[recv_len] = '';
            ESP_LOGI(TAG, "Received command: %s", recv_buf);
            process_mqtt_command(recv_buf);
        }
        
        // 心跳保持
        air724_mqtt_keep_alive();
        
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

// ===================== 4G模块初始化检查 =====================
static void check_4g_connection(void)
{
    ESP_LOGI(TAG, "Initializing 4G module...");
    
    // 给4G模块上电
    gpio_set_level(UART_4G_PWR_KEY, 1);
    vTaskDelay(pdMS_TO_TICKS(1000));
    
    // 等待网络注册
    int retry = 0;
    while (!air724_is_network_ready() && retry < 30) {
        ESP_LOGI(TAG, "Waiting for network registration... (%d/30)", retry + 1);
        vTaskDelay(pdMS_TO_TICKS(2000));
        retry++;
    }
    
    if (retry >= 30) {
        ESP_LOGW(TAG, "4G network registration timeout");
    } else {
        ESP_LOGI(TAG, "4G network ready");
    }
}

// ===================== 初始化所有任务 =====================
static void init_tasks(void)
{
    // 创建按键队列
    g_key_queue = xQueueCreate(10, sizeof(key_event_t));
    
    // 创建按键扫描任务
    xTaskCreate(key_scan_task, "key_scan", 2048, NULL, 5, NULL);
    
    // 创建传感器读取任务
    xTaskCreate(sensor_read_task, "sensor_read", 4096, NULL, 4, NULL);
    
    // 创建MQTT任务
    xTaskCreate(mqtt_task, "mqtt_task", 8192, NULL, 3, &g_mqtt_task_handle);
    
    ESP_LOGI(TAG, "All tasks created");
}

// ===================== 主函数 =====================
void app_main(void)
{
    // 初始化NVS
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        ESP_ERROR_CHECK(nvs_flash_erase());
        ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK(ret);
    
    ESP_LOGI(TAG, "=== Watermelon Seedling Monitoring System ===");
    ESP_LOGI(TAG, "ESP32-S3 based system starting...");
    
    // 初始化各外设
    init_gpio();
    init_i2c();
    init_spi_lcd();
    init_adc();
    init_uart_4g();
    
    // 初始化传感器
    sht30_init();
    bh1750_init();
    sgp30_init();
    
    // 初始化LCD显示
    lcd_st7789_clear(0x0000);
    lcd_st7789_draw_string("System Init...", 0, 50, 0xFFFF, 0x0000);
    
    // 检查4G模块
    check_4g_connection();
    
    // 创建任务
    init_tasks();
    
    ESP_LOGI(TAG, "System initialization complete!");
    lcd_st7789_clear(0x0000);
}

使用说明：

1. 本代码基于ESP-IDF v5.0及以上版本开发，需要配置好ESP-IDF开发环境

2. 需要包含以下组件库：sht30、bh1750、sgp30、lcd_st7789、air724

3. 传感器驱动需实现对应的初始化、读取函数接口

4. Air724模块驱动需实现MQTT连接、发布、订阅、接收等基础功能

5. 代码实现了完整的三任务架构：按键扫描、传感器读取与控制、MQTT通信

6. 所有传感器数据采集、LCD显示、自动控制逻辑、远程指令处理均已完整实现

六、总结

综上所述，本系统以ESP32-S3为主控核心，集成SHT30温湿度传感器、BH1750光照传感器、SGP30二氧化碳传感器及土壤湿度传感器，搭配1.44寸LCD本地显示、4G模块云上通信、继电器驱动执行机构，构成了一套功能完整、运行可靠的西瓜育苗环境智能监控系统。系统成功实现了环境参数的实时采集与本地显示、自动与手动双模式控制、远程数据监控与指令下发等核心功能，有效解决了传统大棚育苗管理中人力依赖性强、响应滞后、缺乏远程监管手段等突出问题。

在技术架构上，系统采用“端-云-应用”三层物联网体系：终端层基于ESP-IDF框架完成硬件驱动与实时控制逻辑，传输层通过Air724 4G模块以MQTT协议对接华为云IoT平台，应用层分别以Qt开发的Android APP和Windows上位机为管理终端，实现了跨平台、多终端的远程监控能力。双模式控制设计兼顾了自动化管理的便捷性与人工干预的灵活性，自动模式下系统能够根据土壤湿度、环境光照和温度阈值自主决策灌溉、补光和通风，而手动模式则为特殊农事操作保留了充分的自主控制权。

本项目的实施不仅为西瓜育苗过程提供了精准、高效的环境管理手段，显著降低了人工巡检成本，同时也为其他设施园艺作物的智能化种植管理提供了可复制、可推广的技术方案。随着5G通信、边缘计算和人工智能技术的持续发展，未来系统可进一步引入基于历史数据的生长模型分析、病虫害图像识别、水肥一体化精准调控等高级功能，推动西瓜育苗乃至整个设施农业向着更加智能化、数据化和精细化的方向持续迈进，为我国智慧农业的发展贡献切实可行的技术力量。