零知IDE——基于STM32与W5500的UDP通信实现温湿度监控

eefocus_4087784

​  ✔零知开源（零知IDE）是一个专为电子初学者/电子兴趣爱好者设计的开源软硬件平台，在硬件上提供超高性价比STM32系列开发板、物联网控制板。取消了Bootloader程序烧录，让开发重心从 “配置环境” 转移到 “创意实现”，极大降低了技术门槛。零知IDE编程软件，内置上千个覆盖多场景的示例代码，支持项目源码一键下载，项目文章在线浏览。零知开源(零知IDE)平台通过软硬件协同创新，让你的创意快速转化为实物，来动手试试吧！

✔访问零知实验室，获取更多实战项目和教程资源吧！
www.lingzhilab.com

项目概述

       本项目基于零知增强板（主控STM32F407VET6）结合W5500以太网模块，实现了一套完整的UDP通信温湿度监控系统。系统通过DHT11传感器实时采集环境温湿度数据，通过W5500以太网模块建立UDP通信链路，将数据发送至PC上位机。同时，上位机可通过UDP协议发送控制指令，远程控制开发板上的LED灯开关状态

项目难点及解决方案

        问题描述：多网卡路由冲突导致路由表混乱，UDP包丢失

解决方案：网段隔离与静态配置，将网络拓扑从混合网段改为独立网段；代码中禁用DHCP功能，网关和DNS强制指向PC的以太网IP；同时网段检测逻辑

一、系统硬件部分1.1 元件清单硬件名称数量备注
零知增强板（STM32F407VET6）                        1主控核心板
W5500 以太网模块1带 SPI 接口的以太网模块
DHT11 温湿度传感器1数字型温湿度传感器
LED 发光二极管1用于远程控制演示
10K 上拉电阻1DHT11 数据脚需接
杜邦线若干连接各模块
网线1PC 与 W5500 直连
PC（带以太网口）1运行 Python 上位机
1.2 接线方案表

请务必严格按照代码中的定义进行连接，否则会导致初始化失败。

零知增强板引脚外接设备设备引脚功能说明
7DHT11DATA温湿度数据传输
8LED正极LED 控制引脚（低电平熄灭）
GNDDHT11/LED/W5500GND公共接地
5VW5500/DHT115V / +供电（W5500 需 5V）
3.3V可选DHT11 (+)DHT11 也可接 3.3V
A5 (SCLK)W5500SCLKSPI 时钟线
A6 (MISO)W5500MISOSPI 主机输入 / 从机输出
A7 (MOSI)W5500MOSISPI 主机输出 / 从机输入
A4 (SCS)W5500CSW5500 片选引脚
1.3 接线示意图

W5500 的 SPI 接线必须严格对应零知增强板 的 SPI 引脚（SCK/MISO/MOSI/CS）

1.4 实物连接图

二、安装与使用部分2.1 开源平台-输入"W5500的UDP通信"并搜索-代码下载自动打开

2.2 连接-验证-上传

2.3 调试-串口监视器

三、核心代码讲解

        本项目的代码设计体现了模块化和健壮性的特点，以下将对核心的四个部分进行详细剖析

3.1 网络初始化与配置

        网络初始化是本项目的核心，采用PC直连静态IP模式，确保通信稳定

1. // ==================== 网络配置 - PC直连模式 ====================
   
2. byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
   
3. 
   
4. // 静态IP配置
   
5. IPAddress staticIP(192, 168, 10, 22);      // W5500的IP
   
6. IPAddress gateway(192, 168, 10, 1);        // 设为PC的以太网卡IP
   
7. IPAddress subnet(255, 255, 255, 0);        
   
8. IPAddress dnsip(192, 168, 10, 1);          // DNS指向PC
   
9. 
   
10. // PC的以太网卡IP
    
11. IPAddress pcIP(192, 168, 10, 17);
    
12. 
    
13. // 网络初始化函数
    
14. void initNetwork() {
    
15.   // 静态IP配置
    
16.   Ethernet.begin(mac, staticIP, dnsip, gateway, subnet);
    
17.   
    
18.   // 验证网络配置
    
19.   IPAddress ip = Ethernet.localIP();
    
20.   if (ip == IPAddress(0, 0, 0, 0)) {
    
21.     Serial.println("✗✗✗ 错误: 以太网初始化失败! ✗✗✗");
    
22.     // 错误处理...
    
23.   }
    
24.   
    
25.   // 启动UDP服务
    
26.   Udp.begin(localPort);
    
27. }

复制代码

PC以太网卡不提供DHCP服务，必须使用静态IP；网关设置指向PC，点对点直连网络

3.2 DHT11数据采集与处理

        DHT11传感器数据采集需要精确的时序控制，并处理可能的读取失败情况

1. // DHT11初始化
   
2. DHT dht(DHTPIN, DHTTYPE);
   
3. 
   
4. // 读取DHT数据函数
   
5. void readDHTData() {
   
6.   unsigned long currentTime = millis();
   
7.   
   
8.   // 每10秒读取一次
   
9.   if (currentTime - lastDHTReadTime >= 10000) {
   
10.     lastDHTReadTime = currentTime;
    
11.    
    
12.     float h = dht.readHumidity();
    
13.     float t = dht.readTemperature();
    
14.    
    
15.     if (isnan(h) || isnan(t)) {
    
16.       Serial.println("✗ DHT11读取失败!");
    
17.       dhtValid = false;
    
18.     } else {
    
19.       humidity = h;
    
20.       temperature = t;
    
21.       dhtValid = true;
    
22.       
    
23.       // 发送数据
    
24.       sendDHTData();
    
25.     }
    
26.   }
    
27. }
    
28. 
    
29. // 发送DHT数据函数
    
30. void sendDHTData() {
    
31.   if (dhtValid) {
    
32.     messageCount++;
    
33.    
    
34.     char tempStr[10];
    
35.     char humiStr[10];
    
36.     floatToString(tempStr, temperature, 2);  // 2位小数精度
    
37.     floatToString(humiStr, humidity, 2);
    
38.    
    
39.     // 构建JSON格式数据
    
40.     snprintf(sendBuffer, sizeof(sendBuffer),
    
41.              "{"type":"dht","count":%lu,"temp":%s,"humi":%s,"time":%lu}",
    
42.              messageCount, tempStr, humiStr, millis() / 1000);
    
43.    
    
44.     sendUDP(sendBuffer);
    
45.   }
    
46. }

复制代码

DHT11设置为10秒的读取间隔，使用自定义floatToString()函数处理浮点数

3.3 UDP通信协议解析

        实现简单的命令解析机制，支持多种控制指令

1. // 协议解析函数
   
2. void parseCommand(const char* cmd, IPAddress remoteIP, int remotePort) {
   
3.   // LED_ON命令
   
4.   if (strcmp(cmd, "LED_ON") == 0) {
   
5.     digitalWrite(LED_CONTROL_PIN, HIGH);
   
6.     ledControlState = true;
   
7.    
   
8.     snprintf(sendBuffer, sizeof(sendBuffer),
   
9.              "{"type":"response","cmd":"LED_ON","status":"success","led_state":true}");
   
10.    
    
11.     Udp.beginPacket(remoteIP, remotePort);
    
12.     Udp.write((uint8_t*)sendBuffer, strlen(sendBuffer));
    
13.     Udp.endPacket();
    
14.   }
    
15.   // GET_DHT命令
    
16.   else if (strcmp(cmd, "GET_DHT") == 0) {
    
17.     float h = dht.readHumidity();
    
18.     float t = dht.readTemperature();
    
19.    
    
20.     if (isnan(h) || isnan(t)) {
    
21.       snprintf(sendBuffer, sizeof(sendBuffer),
    
22.                "{"type":"response","cmd":"GET_DHT","status":"error","error":"read_failed"}");
    
23.     } else {
    
24.       char tempStr[10];
    
25.       char humiStr[10];
    
26.       floatToString(tempStr, t, 2);
    
27.       floatToString(humiStr, h, 2);
    
28.       
    
29.       snprintf(sendBuffer, sizeof(sendBuffer),
    
30.                "{"type":"response","cmd":"GET_DHT","status":"success","temp":%s,"humi":%s}",
    
31.                tempStr, humiStr);
    
32.     }
    
33.    
    
34.     Udp.beginPacket(remoteIP, remotePort);
    
35.     Udp.write((uint8_t*)sendBuffer, strlen(sendBuffer));
    
36.     Udp.endPacket();
    
37.   }
    
38.   // 其他命令处理...
    
39. }

复制代码

支持的命令列表
指令功能说明返回信息
LED_ON点亮LED返回成功状态和LED状态
LED_OFF熄灭LED返回成功状态和LED状态
GET_DHT读取实时温湿度返回数据或错误信息
STATUS获取设备完整状态信息返回设备状态每个命令都有明确的成功/失败状态返回，接收到命令后立即处理并返回结果

3.4 系统状态维护与心跳机制

        系统需要维护多个状态变量，并实现心跳机制确保连接正常

1. // 全局状态变量
   
2. unsigned long lastDHTReadTime = 0;    // 上次DHT读取时间
   
3. unsigned long lastSendTime = 0;       // 上次发送时间
   
4. unsigned long messageCount = 0;       // 消息计数器
   
5. unsigned long lastHeartbeat = 0;      // 上次心跳时间
   
6. 
   
7. bool dhtValid = false;                // DHT数据有效性
   
8. bool ledControlState = false;         // LED控制状态
   
9. bool networkInitialized = false;      // 网络初始化状态
   
10. 
    
11. unsigned long packetsSent = 0;        // 发送数据包计数
    
12. unsigned long packetsReceived = 0;    // 接收数据包计数
    
13. 
    
14. // 心跳包发送函数
    
15. void sendHeartbeat() {
    
16.   unsigned long currentTime = millis();
    
17.   
    
18.   if (currentTime - lastHeartbeat >= 30000) {  // 每30秒
    
19.     lastHeartbeat = currentTime;
    
20.    
    
21.     snprintf(sendBuffer, sizeof(sendBuffer),
    
22.              "{"type":"heartbeat","uptime":%lu,"packets_sent":%lu,"packets_received":%lu}",
    
23.              millis() / 1000, packetsSent, packetsReceived);
    
24.     sendUDP(sendBuffer);
    
25.   }
    
26. }
    
27. 
    
28. // 状态LED指示函数
    
29. void updateStatusLED() {
    
30.   unsigned long currentTime = millis();
    
31.   
    
32.   if (currentTime - lastBlinkTime >= 500) {  // 每500ms闪烁一次
    
33.     lastBlinkTime = currentTime;
    
34.     ledBlinkState = !ledBlinkState;
    
35.     digitalWrite(LED_BUILTIN, ledBlinkState ? LOW : HIGH);
    
36.   }
    
37. }

复制代码

统计发送和接收的数据包数量，用于监控通信质量；定期发送心跳包，让上位机知道设备在线状态

3.5 系统完整代码

1. /**************************************************************************************
   
2. * 文件: W5500_UDP_DHT11_Control.ino
   
3. * 作者:零知实验室(深圳市在芯间科技有限公司)
   
4. * -^^- 零知实验室,让电子制作变得更简单! -^^-
   
5. * 时间: 2026-02-09
   
6. * 网络拓扑:
   
7. *   路由器(192.168.3.1) ←WiFi→ PC(WiFi: 192.168.3.17, 以太网: 192.168.10.1)
   
8. *                                    ↓ 直连网线
   
9. *                               W5500(192.168.10.22)
   
10. *
    
11. * 功能说明:
    
12. * W5500以太网模块UDP通信、DHT11温湿度传感器数据采集和上报、远程LED控制功能、简单协议解析和响应、修复JSON浮点数格式化问题（snprintf不支持%f）
    
13. ************************************************************************************/
    
14. 
    
15. #include <SPI.h>
    
16. #include <Ethernet_STM.h>
    
17. #include <EthernetUdp.h>
    
18. #include "DHT.h"
    
19. 
    
20. // ==================== 硬件配置 ====================
    
21. #define DHTPIN 7
    
22. #define DHTTYPE DHT11
    
23. DHT dht(DHTPIN, DHTTYPE);
    
24. 
    
25. #define LED_CONTROL_PIN 8
    
26. 
    
27. 
    
28. // ==================== 网络配置 - PC直连模式 ====================
    
29. #if defined(WIZ550io_WITH_MACADDRESS)
    
30.   // WIZ550io有内置MAC地址
    
31. #else
    
32.   byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
    
33. #endif
    
34. 
    
35. //  PC直连模式 - 必须使用静态IP!
    
36. // PC的以太网卡不提供DHCP服务,所以DHCP无法工作
    
37. #define USE_DHCP false
    
38. 
    
39. // ==================== 重要: 网段配置说明 ====================
    
40. // 使用 192.168.10.x 网段,与PC的WiFi网段(192.168.3.x)分开
    
41. // 避免IP冲突和路由混乱
    
42. 
    
43. // 静态IP配置
    
44. IPAddress staticIP(192, 168, 10, 22);      // W5500的IP
    
45. IPAddress gateway(192, 168, 10, 1);        // 设为PC的以太网卡IP
    
46. IPAddress subnet(255, 255, 255, 0);        
    
47. IPAddress dnsip(192, 168, 10, 1);          // DNS指向PC
    
48. 
    
49. // PC的以太网卡IP (连接W5500的那个网卡)
    
50. //  不是WiFi的IP (192.168.3.17)!
    
51. IPAddress pcIP(192, 168, 10, 17);
    
52. 
    
53. // UDP端口
    
54. unsigned int localPort = 8888;
    
55. unsigned int pcPort = 9003;
    
56. 
    
57. // ==================== 如果您的PC以太网卡IP是其他值 ====================
    
58. // 请相应修改上面的配置,例如:
    
59. //
    
60. // 如果PC以太网卡是 192.168.137.1 (启用了ICS):
    
61. //   IPAddress staticIP(192, 168, 137, 22);
    
62. //   IPAddress gateway(192, 168, 137, 1);
    
63. //   IPAddress dnsip(192, 168, 137, 1);
    
64. //   IPAddress pcIP(192, 168, 137, 1);
    
65. //
    
66. // 如果PC以太网卡是 192.168.3.215 (不推荐,会与WiFi冲突):
    
67. //   IPAddress staticIP(192, 168, 3, 22);
    
68. //   IPAddress gateway(192, 168, 3, 215);  // 指向PC,不是路由器!
    
69. //   IPAddress dnsip(192, 168, 3, 215);
    
70. //   IPAddress pcIP(192, 168, 3, 215);
    
71. 
    
72. 
    
73. // ==================== 全局变量 ====================
    
74. EthernetUDP Udp;
    
75. char receiveBuffer[256];
    
76. char sendBuffer[512];
    
77. 
    
78. // 定时器
    
79. unsigned long lastDHTReadTime = 0;
    
80. unsigned long lastSendTime = 0;
    
81. unsigned long messageCount = 0;
    
82. unsigned long lastHeartbeat = 0;
    
83. 
    
84. // DHT数据
    
85. float temperature = 0.0;
    
86. float humidity = 0.0;
    
87. bool dhtValid = false;
    
88. 
    
89. // LED状态
    
90. bool ledControlState = false;
    
91. unsigned long lastBlinkTime = 0;
    
92. bool ledBlinkState = false;
    
93. 
    
94. // 网络状态
    
95. bool networkInitialized = false;
    
96. unsigned long lastSuccessTime = 0;
    
97. unsigned long packetsSent = 0;
    
98. unsigned long packetsReceived = 0;
    
99. 
    
100. 
     
101. // ==================== 函数声明 ====================
     
102. void floatToString(char* buffer, float value, int decimalPlaces);
     
103. 
     
104. 
     
105. // ==================== 浮点数转字符串 ====================
     
106. void floatToString(char* buffer, float value, int decimalPlaces) {
     
107.   int intPart = (int)value;
     
108.   int decPart = (int)((value - intPart) * pow(10, decimalPlaces));
     
109.   
     
110.   if (decPart < 0) decPart = -decPart;
     
111.   
     
112.   if (decimalPlaces == 1) {
     
113.     sprintf(buffer, "%d.%01d", intPart, decPart);
     
114.   } else if (decimalPlaces == 2) {
     
115.     sprintf(buffer, "%d.%02d", intPart, decPart);
     
116.   }
     
117. }
     
118. 
     
119. 
     
120. // ==================== 初始化 ====================
     
121. void setup() {
     
122.   Serial.begin(115200);
     
123.   delay(100);
     
124.   
     
125.   Serial.println("\n\n");
     
126.   Serial.println("========================================");
     
127.   Serial.println("  W5500 UDP + DHT11温湿度监控系统");
     
128.   Serial.println("  零知实验室");
     
129.   Serial.println("  版本: v3.1 (PC直连专用版)");
     
130.   Serial.println("========================================\n");
     
131.   
     
132.   Serial.println("  网络模式: PC直连(静态IP)");
     
133.   Serial.println("  请确保PC的以太网卡已配置静态IP!\n");
     
134.   
     
135.   initHardware();
     
136.   initNetwork();
     
137.   initDHT();
     
138.   
     
139.   Serial.println("\n========================================");
     
140.   Serial.println("系统启动完成!");
     
141.   Serial.println("========================================\n");
     
142.   
     
143.   printSystemInfo();
     
144.   sendStartupMessage();
     
145.   
     
146.   Serial.println("\n开始工作...\n");
     
147.   Serial.println("----------------------------------------\n");
     
148. }
     
149. 
     
150. 
     
151. // ==================== 硬件初始化 ====================
     
152. void initHardware() {
     
153.   Serial.println("[1/3] 初始化硬件...");
     
154.   
     
155.   pinMode(LED_BUILTIN, OUTPUT);
     
156.   digitalWrite(LED_BUILTIN, HIGH);
     
157.   
     
158.   pinMode(LED_CONTROL_PIN, OUTPUT);
     
159.   digitalWrite(LED_CONTROL_PIN, LOW);
     
160.   ledControlState = false;
     
161.   
     
162.   // 启动提示 - LED快闪3次
     
163.   for(int i = 0; i < 3; i++) {
     
164.     digitalWrite(LED_BUILTIN, LOW);
     
165.     delay(100);
     
166.     digitalWrite(LED_BUILTIN, HIGH);
     
167.     delay(100);
     
168.   }
     
169.   
     
170.   Serial.println("✓ 硬件初始化完成!");
     
171. }
     
172. 
     
173. 
     
174. // ==================== 网络初始化 ====================
     
175. void initNetwork() {
     
176.   Serial.println("\n[2/3] 初始化W5500以太网模块...");
     
177.   Serial.println("  模式: 静态IP (PC直连)");
     
178.   delay(500);
     
179.   
     
180.   // 静态IP配置
     
181.   #if defined(WIZ550io_WITH_MACADDRESS)
     
182.     Ethernet.begin(staticIP, dnsip, gateway, subnet);
     
183.   #else
     
184.     Ethernet.begin(mac, staticIP, dnsip, gateway, subnet);
     
185.   #endif
     
186.   
     
187.   delay(1000);
     
188.   
     
189.   // 验证网络配置
     
190.   IPAddress ip = Ethernet.localIP();
     
191.   
     
192.   if (ip == IPAddress(0, 0, 0, 0)) {
     
193.     Serial.println("\n✗✗✗ 错误: 以太网初始化失败! ✗✗✗");
     
194.     Serial.println("\n请检查:");
     
195.     Serial.println("  1. W5500模块SPI接线是否正确");
     
196.     Serial.println("  2. 网线是否连接到PC的以太网口");
     
197.     Serial.println("  3. PC的以太网卡是否已配置静态IP");
     
198.     Serial.println("\n设备将进入错误指示模式");
     
199.    
     
200.     while(1) {
     
201.       digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
     
202.       delay(100);
     
203.     }
     
204.   }
     
205.   
     
206.   Serial.println("\n✓ W5500初始化成功!");
     
207.   Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
     
208.   Serial.print("  本机IP:   ");
     
209.   Serial.println(ip);
     
210.   Serial.print("  子网掩码: ");
     
211.   Serial.println(Ethernet.subnetMask());
     
212.   Serial.print("  网关:     ");
     
213.   Serial.println(Ethernet.gatewayIP());
     
214.   Serial.print("  DNS:      ");
     
215.   Serial.println(Ethernet.dnsServerIP());
     
216.   Serial.println("  模式:     静态IP (PC直连)");
     
217.   Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
     
218.   
     
219.   // 显示PC配置提示
     
220.   Serial.println("\n📌 PC网络配置要求:");
     
221.   Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
     
222.   Serial.print("  以太网卡IP: ");
     
223.   Serial.println(pcIP);
     
224.   Serial.print("  子网掩码:   ");
     
225.   Serial.println(subnet);
     
226.   Serial.println("  默认网关:   (留空)");
     
227.   Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
     
228.   Serial.println("  请确保PC的以太网卡已设置为上述静态IP!");
     
229.   Serial.println("   否则无法通信!\n");
     
230.   
     
231.   // 启动UDP
     
232.   Serial.println("[3/3] 启动UDP服务...");
     
233.   Udp.begin(localPort);
     
234.   Serial.print("  - 监听端口: ");
     
235.   Serial.println(localPort);
     
236.   Serial.print("  - 目标PC:   ");
     
237.   Serial.print(pcIP);
     
238.   Serial.print(":");
     
239.   Serial.println(pcPort);
     
240.   Serial.println("✓ UDP服务启动成功!");
     
241.   
     
242.   networkInitialized = true;
     
243. }
     
244. 
     
245. 
     
246. // ==================== DHT11初始化 ====================
     
247. void initDHT() {
     
248.   Serial.println("\n初始化DHT11传感器...");
     
249.   dht.begin();
     
250.   delay(2000);
     
251.   
     
252.   humidity = dht.readHumidity();
     
253.   temperature = dht.readTemperature();
     
254.   
     
255.   if (isnan(humidity) || isnan(temperature)) {
     
256.     Serial.println("    DHT11首次读取失败,将继续尝试...");
     
257.     dhtValid = false;
     
258.   } else {
     
259.     Serial.println("✓ DHT11初始化成功!");
     
260.     Serial.print("  - 温度: ");
     
261.     Serial.print(temperature);
     
262.     Serial.println(" °C");
     
263.     Serial.print("  - 湿度: ");
     
264.     Serial.print(humidity);
     
265.     Serial.println(" %");
     
266.     dhtValid = true;
     
267.   }
     
268. }
     
269. 
     
270. 
     
271. // ==================== 系统信息显示 ====================
     
272. void printSystemInfo() {
     
273.   Serial.println("\n系统配置: ");
     
274.   Serial.print("  - DHT11引脚: ");
     
275.   Serial.println(DHTPIN);
     
276.   Serial.print("  - LED控制引脚: ");
     
277.   Serial.println(LED_CONTROL_PIN);
     
278.   Serial.println("  - 网络模式: PC直连静态IP");
     
279.   Serial.println("\n支持的命令:");
     
280.   Serial.println("  - LED_ON     : 点亮LED");
     
281.   Serial.println("  - LED_OFF    : 熄灭LED");
     
282.   Serial.println("  - GET_DHT    : 立即获取温湿度");
     
283.   Serial.println("  - STATUS     : 获取设备状态");
     
284.   Serial.println("  - PING       : 测试连接");
     
285.   Serial.println("\n自动功能:");
     
286.   Serial.println("  - 每10秒自动上报温湿度数据");
     
287.   Serial.println("  - 每30秒发送心跳包");
     
288.   Serial.println("  - 板载LED慢闪表示正常运行");
     
289.   
     
290.   Serial.println("\n网络诊断:");
     
291.   Serial.print("  - W5500 IP: ");
     
292.   Serial.println(Ethernet.localIP());
     
293.   Serial.print("  - PC IP:    ");
     
294.   Serial.println(pcIP);
     
295.   Serial.print("  - 是否同网段: ");
     
296.   
     
297.   // 检查是否在同一网段
     
298.   IPAddress w5500IP = Ethernet.localIP();
     
299.   bool sameSubnet = (w5500IP[0] == pcIP[0] &&
     
300.                      w5500IP[1] == pcIP[1] &&
     
301.                      w5500IP[2] == pcIP[2]);
     
302.   
     
303.   if (sameSubnet) {
     
304.     Serial.println("✓ 是");
     
305.   } else {
     
306.     Serial.println("✗ 否 (无法通信!)");
     
307.     Serial.println("\n [警告] IP地址不在同一网段!");
     
308.     Serial.println("请检查网络配置!");
     
309.   }
     
310. }
     
311. 
     
312. 
     
313. // ==================== 发送启动消息 ====================
     
314. void sendStartupMessage() {
     
315.   IPAddress ip = Ethernet.localIP();
     
316.   
     
317.   snprintf(sendBuffer, sizeof(sendBuffer),
     
318.            "{"type":"startup","ip":"%d.%d.%d.%d","port":%d,"mode":"pc_direct","pc_ip":"%d.%d.%d.%d"}",
     
319.            ip[0], ip[1], ip[2], ip[3],
     
320.            localPort,
     
321.            pcIP[0], pcIP[1], pcIP[2], pcIP[3]);
     
322.   sendUDP(sendBuffer);
     
323.   
     
324.   Serial.println("📤 已发送启动消息到PC");
     
325. }
     
326. 
     
327. 
     
328. // ==================== 发送心跳包 ====================
     
329. void sendHeartbeat() {
     
330.   unsigned long currentTime = millis();
     
331.   
     
332.   if (currentTime - lastHeartbeat >= 30000) {
     
333.     lastHeartbeat = currentTime;
     
334.    
     
335.     snprintf(sendBuffer, sizeof(sendBuffer),
     
336.              "{"type":"heartbeat","uptime":%lu,"packets_sent":%lu,"packets_received":%lu}",
     
337.              millis() / 1000, packetsSent, packetsReceived);
     
338.     sendUDP(sendBuffer);
     
339.    
     
340.     Serial.println(" 心跳包");
     
341.   }
     
342. }
     
343. 
     
344. 
     
345. // ==================== 读取DHT11数据 ====================
     
346. void readDHTData() {
     
347.   unsigned long currentTime = millis();
     
348.   
     
349.   if (currentTime - lastDHTReadTime >= 10000) {
     
350.     lastDHTReadTime = currentTime;
     
351.    
     
352.     float h = dht.readHumidity();
     
353.     float t = dht.readTemperature();
     
354.    
     
355.     if (isnan(h) || isnan(t)) {
     
356.       Serial.println("✗ DHT11读取失败!");
     
357.       dhtValid = false;
     
358.     } else {
     
359.       humidity = h;
     
360.       temperature = t;
     
361.       dhtValid = true;
     
362.       
     
363.       Serial.println("📊 DHT11数据:");
     
364.       Serial.print("  温度: ");
     
365.       Serial.print(temperature);
     
366.       Serial.println(" °C");
     
367.       Serial.print("  湿度: ");
     
368.       Serial.print(humidity);
     
369.       Serial.println(" %");
     
370.       
     
371.       sendDHTData();
     
372.     }
     
373.   }
     
374. }
     
375. 
     
376. 
     
377. // ==================== 发送DHT数据 ====================
     
378. void sendDHTData() {
     
379.   if (dhtValid) {
     
380.     messageCount++;
     
381.    
     
382.     char tempStr[10];
     
383.     char humiStr[10];
     
384.     floatToString(tempStr, temperature, 2);
     
385.     floatToString(humiStr, humidity, 2);
     
386.    
     
387.     snprintf(sendBuffer, sizeof(sendBuffer),
     
388.              "{"type":"dht","count":%lu,"temp":%s,"humi":%s,"time":%lu}",
     
389.              messageCount, tempStr, humiStr, millis() / 1000);
     
390.    
     
391.     sendUDP(sendBuffer);
     
392.    
     
393.     Serial.print("📤 已发送温湿度数据 #");
     
394.     Serial.println(messageCount);
     
395.   }
     
396. }
     
397. 
     
398. 
     
399. // ==================== 发送UDP数据 ====================
     
400. void sendUDP(const char* message) {
     
401.   if (!networkInitialized) {
     
402.     Serial.println("  网络未初始化,无法发送");
     
403.     return;
     
404.   }
     
405.   
     
406.   Udp.beginPacket(pcIP, pcPort);
     
407.   Udp.write((uint8_t*)message, strlen(message));
     
408.   Udp.endPacket();
     
409.   
     
410.   packetsSent++;
     
411.   lastSuccessTime = millis();
     
412. }
     
413. 
     
414. 
     
415. // ==================== 协议解析 ====================
     
416. void parseCommand(const char* cmd, IPAddress remoteIP, int remotePort) {
     
417.   Serial.print("📝 解析命令: ");
     
418.   Serial.println(cmd);
     
419.   
     
420.   // LED_ON
     
421.   if (strcmp(cmd, "LED_ON") == 0) {
     
422.     digitalWrite(LED_CONTROL_PIN, HIGH);
     
423.     ledControlState = true;
     
424.    
     
425.     snprintf(sendBuffer, sizeof(sendBuffer),
     
426.              "{"type":"response","cmd":"LED_ON","status":"success","led_state":true}");
     
427.    
     
428.     Udp.beginPacket(remoteIP, remotePort);
     
429.     Udp.write((uint8_t*)sendBuffer, strlen(sendBuffer));
     
430.     Udp.endPacket();
     
431.    
     
432.     Serial.println("✓ LED已点亮");
     
433.   }
     
434.   // LED_OFF
     
435.   else if (strcmp(cmd, "LED_OFF") == 0) {
     
436.     digitalWrite(LED_CONTROL_PIN, LOW);
     
437.     ledControlState = false;
     
438.    
     
439.     snprintf(sendBuffer, sizeof(sendBuffer),
     
440.              "{"type":"response","cmd":"LED_OFF","status":"success","led_state":false}");
     
441.    
     
442.     Udp.beginPacket(remoteIP, remotePort);
     
443.     Udp.write((uint8_t*)sendBuffer, strlen(sendBuffer));
     
444.     Udp.endPacket();
     
445.    
     
446.     Serial.println("✓ LED已熄灭");
     
447.   }
     
448.   // GET_DHT
     
449.   else if (strcmp(cmd, "GET_DHT") == 0) {
     
450.     float h = dht.readHumidity();
     
451.     float t = dht.readTemperature();
     
452.    
     
453.     if (isnan(h) || isnan(t)) {
     
454.       snprintf(sendBuffer, sizeof(sendBuffer),
     
455.                "{"type":"response","cmd":"GET_DHT","status":"error","error":"read_failed"}");
     
456.     } else {
     
457.       humidity = h;
     
458.       temperature = t;
     
459.       dhtValid = true;
     
460.       
     
461.       char tempStr[10];
     
462.       char humiStr[10];
     
463.       floatToString(tempStr, temperature, 2);
     
464.       floatToString(humiStr, humidity, 2);
     
465.       
     
466.       snprintf(sendBuffer, sizeof(sendBuffer),
     
467.                "{"type":"response","cmd":"GET_DHT","status":"success","temp":%s,"humi":%s}",
     
468.                tempStr, humiStr);
     
469.     }
     
470.    
     
471.     Udp.beginPacket(remoteIP, remotePort);
     
472.     Udp.write((uint8_t*)sendBuffer, strlen(sendBuffer));
     
473.     Udp.endPacket();
     
474.    
     
475.     Serial.println("✓ 已发送DHT数据");
     
476.   }
     
477.   // PING
     
478.   else if (strcmp(cmd, "PING") == 0) {
     
479.     snprintf(sendBuffer, sizeof(sendBuffer),
     
480.              "{"type":"response","cmd":"PING","status":"success","message":"PONG"}");
     
481.    
     
482.     Udp.beginPacket(remoteIP, remotePort);
     
483.     Udp.write((uint8_t*)sendBuffer, strlen(sendBuffer));
     
484.     Udp.endPacket();
     
485.    
     
486.     Serial.println("✓ PONG");
     
487.   }
     
488.   // STATUS
     
489.   else if (strcmp(cmd, "STATUS") == 0) {
     
490.     char tempStr[10];
     
491.     char humiStr[10];
     
492.     floatToString(tempStr, temperature, 2);
     
493.     floatToString(humiStr, humidity, 2);
     
494.    
     
495.     IPAddress ip = Ethernet.localIP();
     
496.    
     
497.     snprintf(sendBuffer, sizeof(sendBuffer),
     
498.              "{"type":"response","cmd":"STATUS","status":"success","uptime":%lu,"led_state":%s,"dht_valid":%s,"temp":%s,"humi":%s,"ip":"%d.%d.%d.%d","mode":"pc_direct","packets_sent":%lu,"packets_received":%lu}",
     
499.              millis() / 1000,
     
500.              ledControlState ? "true" : "false",
     
501.              dhtValid ? "true" : "false",
     
502.              tempStr, humiStr,
     
503.              ip[0], ip[1], ip[2], ip[3],
     
504.              packetsSent, packetsReceived);
     
505.    
     
506.     Udp.beginPacket(remoteIP, remotePort);
     
507.     Udp.write((uint8_t*)sendBuffer, strlen(sendBuffer));
     
508.     Udp.endPacket();
     
509.    
     
510.     Serial.println("✓ 已发送设备状态");
     
511.   }
     
512.   // 未知命令
     
513.   else {
     
514.     snprintf(sendBuffer, sizeof(sendBuffer),
     
515.              "{"type":"response","cmd":"%s","status":"error","error":"unknown_command"}",
     
516.              cmd);
     
517.    
     
518.     Udp.beginPacket(remoteIP, remotePort);
     
519.     Udp.write((uint8_t*)sendBuffer, strlen(sendBuffer));
     
520.     Udp.endPacket();
     
521.    
     
522.     Serial.println("✗ 未知命令");
     
523.   }
     
524. }
     
525. 
     
526. 
     
527. // ==================== 接收UDP数据 ====================
     
528. void receiveUDP() {
     
529.   int packetSize = Udp.parsePacket();
     
530.   
     
531.   if (packetSize > 0) {
     
532.     int len = Udp.read(receiveBuffer, sizeof(receiveBuffer) - 1);
     
533.     if (len > 0) {
     
534.       receiveBuffer[len] = '\0';
     
535.       
     
536.       IPAddress remoteIP = Udp.remoteIP();
     
537.       int remotePort = Udp.remotePort();
     
538.       
     
539.       Serial.println("📥 收到消息:");
     
540.       Serial.print("  来源: ");
     
541.       Serial.print(remoteIP);
     
542.       Serial.print(":");
     
543.       Serial.println(remotePort);
     
544.       Serial.print("  内容: ");
     
545.       Serial.println(receiveBuffer);
     
546.       
     
547.       packetsReceived++;
     
548.       lastSuccessTime = millis();
     
549.       
     
550.       parseCommand(receiveBuffer, remoteIP, remotePort);
     
551.       
     
552.       Serial.println();
     
553.     }
     
554.   }
     
555. }
     
556. 
     
557. 
     
558. // ==================== LED状态指示 ====================
     
559. void updateStatusLED() {
     
560.   unsigned long currentTime = millis();
     
561.   
     
562.   if (currentTime - lastBlinkTime >= 500) {
     
563.     lastBlinkTime = currentTime;
     
564.     ledBlinkState = !ledBlinkState;
     
565.     digitalWrite(LED_BUILTIN, ledBlinkState ? LOW : HIGH);
     
566.   }
     
567. }
     
568. 
     
569. 
     
570. // ==================== 主循环 ====================
     
571. void loop() {
     
572.   // 读取DHT11数据(每10秒)
     
573.   readDHTData();
     
574.   
     
575.   // 发送心跳包(每30秒)
     
576.   sendHeartbeat();
     
577.   
     
578.   // 处理UDP数据
     
579.   receiveUDP();
     
580.   
     
581.   // 更新状态LED
     
582.   updateStatusLED();
     
583.   
     
584.   delay(10);
     
585. }
     

复制代码

系统流程图

UDP传输协议原理

        UDP用户数据报协议发送数据前不需要建立连接，直接发送；协议头仅8字节，相比TCP的20字节更节省带宽；没有握手和确认过程，延迟更低

UDP实现

1. // 发送UDP数据
   
2. void sendUDP(const char* message) {
   
3.   Udp.beginPacket(pcIP, pcPort);      // 开始数据包
   
4.   Udp.write((uint8_t*)message, strlen(message));  // 写入数据
   
5.   Udp.endPacket();                     // 结束并发送
   
6.   
   
7.   packetsSent++;  // 更新统计
   
8. }
   
9. 
   
10. // 接收UDP数据
    
11. void receiveUDP() {
    
12.   int packetSize = Udp.parsePacket();  // 检查是否有数据包
    
13.   
    
14.   if (packetSize > 0) {
    
15.     int len = Udp.read(receiveBuffer, sizeof(receiveBuffer) - 1);
    
16.     if (len > 0) {
    
17.       receiveBuffer[len] = '\0';  // 添加字符串结束符
    
18.       // 处理接收到的数据...
    
19.     }
    
20.   }
    
21. }

复制代码

UDP数据包结构

四、项目结果演示4.1 操作流程

        将PC以太网口的IP设为192.168.10.17，子网掩码255.255.255.0，网关192.168.10.1；运行 Python 代码，确认 UDP 服务启动，监听 9003 端口

以太网配置：

上位机启动：

        通过命令行启动程序，执行python udp_dht_controller.py启动python端上位机

功能测试：
①查看串口监视器，确认每 10 秒采集一次温湿度并发送

②在 Python 菜单中选择 1/2 控制 LED 开关，选择 3 获取实时温湿度，选择 4 查看设备状态

③观察 PC 端是否能收到心跳包（每 30 秒一次）

4.2 网络调试助手演示

        除 Python 上位机外，也可使用网络调试助手测试 UDP 通信，测试时确保python上位机关闭并且PC的IP地址和端口没有被占用

①打开网络调试助手，选择UDP客户端，本地端口9003，远程IP 192.168.10.22，远程端口8888

②发送'LED_ON'，可收到设备端返回的JSON响应

③切换到UDP服务端，监听9003端口，可接收设备端发送的温湿度数据和心跳包

4.3 视频演示
基于W5500的UDP温湿度监控与LED 远程控制系统
视频演示了Python上位机和网络调试助手作为UDP客户端的完整操作流程。展示程序启动界面和配置网络调试助手的本地IP和端口，展示自动上报的温湿度数据。通过菜单选择，python上位机演示了LED点亮/熄灭控制、手动获取温湿度数据、查询设备状态等功能。网络调试助手向设备发送文本命令可以实时接收到JSON格式响应

五、W5500模块技术讲解W5500 核心特性

        支持TCP、UDP、ICMP、IPv4、ARP、IGMP等协议；可同时处理8个网络连接、支持最高80MHz的SPI时钟频率

5.1 SPI通信接口W5500通过SPI接口与主控MCU通信，SPI时序图如下：

SPI帧格式

        W5500 SPI帧由地址阶段的16位偏移地址、8位控制阶段以及N字节数据阶段组成。8位控制阶段由块选择位（BSB[4:0]）、读/写访问模式位（RWB）和SPI操作模式（OM[1:0]）重新配置。块选择位用于选择偏移地址所属的块。

W5500 支持连续数据读写。它从基准位置（为 2/4/N 字节连续数据处理设置的偏移地址）开始处理数据，并且通过将偏移地址增加 1（自动递增寻址）来处理下一个数据。

5.2 寄存器结构通用寄存器块

        通用寄存器用于配置 W5500 的通用信息 IP 地址和 MAC 地址，通过 SPI 帧中的 BSB [4:0] 值选择该寄存器块

GAR（网关地址寄存器）存储网关IP地址、SUBR（子网掩码寄存器）存储子网掩码
Socket 寄存器块

        W5500 支持 8 个用于通信通道的 Socket。每个 Socket 由 Socket n 寄存器块 控制（其中 0≤n≤7）。可通过 SPI 帧中的 BSB[4:0] 选择 Socket n 寄存器的 n 值。

Sn_MR（Socket模式寄存器）设置Socket工作模式、Sn_CR（Socket命令寄存器）执行Socket命令

W5500 在本项目中的工作原理

六、常见问题解答（FAQ）Q1: W5500模块无法初始化，串口显示IP为全0或者全255

        A：可能的原因和解决方案：SPI接线错误、电源问题或者硬件故障，检查SCK、MISO、MOSI、CS、RST引脚，检查3.3V电源供电和SPI时钟频率配置，如果仍然有问题尝试更换W5500模块

Q2: PC无法ping通W5500设备

        A：网络配置检查步骤：确认W5500和PC在同一网段，确认双方子网掩码相同、临时关闭Windows防火墙测试、尝试更换网线或检查RJ45接口、确认PC以太网卡已启用且配置了正确的静态IP

Q3:  UDP通信不稳定，偶尔丢包

        A：提高UDP通信稳定性的方法：确保单次发送数据不超过1472字节、重要数据可在应用层实现简单的确认重发、避免过高的发送频率，给网络处理留出时间

项目资源整合
网络调试助手和上位机程序：  

resource.zip (636.16 KB, 下载次数: 0)

2026-2-28 16:49 上传

点击文件名下载附件

W5500数据手册：                  

W5500_ds_v110e.pdf (1.81 MB, 下载次数: 0)

2026-2-28 16:49 上传

点击文件名下载附件

W5500以太网库文件：            Ethernet_STM