STM32F1网络编程-W5500-动态获取IP（DHCP）

W5500-动态获取IP（DHCP）

在前面的文章中，我们成功将W5500的驱动成功移植，并以静态方式配置W5500的IP。本文在前面文章介绍内容的基础上，详细介绍如何配置W5500动态获取IP，即DHCP方式分配IP。

配置W5500的DHCP方式步主要骤如下：

  • 第一步，设置网卡属性为NETINFO_DHCP
  • 第二步，设置网卡信息
  • 第三步，初始化W5500芯片
  • 第四步，DHCP初始化
  • 第五步，注册DHCP回调函数
  • 第六步，通过调用DHCP_run函数查询

DHCP移植基本定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/\*
 \* w5500\_port.h
 \*
 \* Created on: 2022年6月29日
 \* Author: jenson
 \*/

#ifndef W5500\_PORT\_H\_
#define W5500\_PORT\_H\_

#define W5500\_USE\_STATIC
//#define W5500\_USE\_DHCP

void wiznet\_register(void);
#ifdef W5500\_USE\_STATIC
void w5500\_network\_init\_static(void);
#else
void w5500\_network\_init\_dhcp(void);
#endif
void wiznet\_chip\_config(void);
void w5500\_restart(void);

#endif /\* W5500\_PORT\_H\_ \*/

DHCP定义实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
/\*
 \* w5500\_port.c
 \*
 \* Created on: 2022年6月29日
 \* Author: jenson
 \*/

#include "w5500\_port.h"
#include "main.h"
#include "spi.h"
#include <stdio.h>
#include "wizchip\_conf.h"
#include "socket.h"
#include "loopback.h"
#include "DHCP/dhcp.h"
#include <string.h>

#ifdef W5500\_USE\_STATIC

static wiz_NetInfo gWIZNETINFO_STATIC = {
		.mac = { 0x00, 0x08, 0xdc, 0x11, 0x11, 0x11 },
		.ip = { 192, 168, 2, 99 },
		.sn = { 255, 255, 255, 0 },
		.gw = { 192, 168,2, 1 },
		.dns = { 8, 8, 8, 8 },
		.dhcp = NETINFO_STATIC
};
#else
static wiz_NetInfo gWIZNETINFO_DHCP = { .mac = { 0x00, 0x08, 0xdc, 0x11, 0x11, 0x11,
		0x11 }, .ip = { 0, 0, 0, 0 }, .sn = { 0, 0, 0, 0 },
		.gw = { 0, 0, 0, 0 }, .dns = { 8, 8, 8, 8 }, .dhcp = NETINFO_DHCP };
#define ETH\_MAX\_BUF\_SIZE 2048
unsigned char ethBuf0[ETH_MAX_BUF_SIZE];
uint8\_t dhcp_retry = 0;
#endif

static void \_\_w5500\_spi\_cs\_select(void) {
	HAL\_GPIO\_WritePin(W5500_CS_GPIO_Port, W5500_CS_Pin, GPIO_PIN_RESET);
}

static void \_\_w5500\_spi\_cs\_deselect(void) {
	HAL\_GPIO\_WritePin(W5500_CS_GPIO_Port, W5500_CS_Pin, GPIO_PIN_SET);
}

#ifdef W5500\_USE\_DHCP
int process\_dhcp(void);
#endif

#ifdef W5500\_USE\_DHCP
void \_\_w5500\_ip\_assign(void)
{
  getIPfromDHCP(gWIZNETINFO_DHCP.ip);
  getGWfromDHCP(gWIZNETINFO_DHCP.gw);
  getSNfromDHCP(gWIZNETINFO_DHCP.sn);
  getDNSfromDHCP(gWIZNETINFO_DHCP.dns);
  gWIZNETINFO_DHCP.dhcp = NETINFO_DHCP;

  ctlnetwork(CN_SET_NETINFO, (void\*)&gWIZNETINFO_DHCP);
}

void \_\_w5500\_ip\_conflict(void)
{
  printf("CONFLICT IP from DHCP \r\n");
  while(1);
}

#endif

void w5500\_restart(void) {
	HAL\_GPIO\_WritePin(W5500_RST_GPIO_Port, W5500_RST_Pin, GPIO_PIN_RESET);
	HAL\_Delay(1);  // delay 1ms
	HAL\_GPIO\_WritePin(W5500_RST_GPIO_Port, W5500_RST_Pin, GPIO_PIN_SET);
	HAL\_Delay(1600);  // delay 1600ms
	printf("w5500 restarted\r\n");
}

/\*\*
 \* @brief? 进入临界区
 \* @retval None
 \*/
void \_\_w5500\_spi\_cris\_enter(void) {
	\_\_set\_PRIMASK(1);
}

/\*\*
 \* @brief? 退出临界区
 \* @retval None
 \*/
void \_\_w5500\_spi\_cris\_exit(void) {
	\_\_set\_PRIMASK(0);
}

static void \_\_w5500\_spi\_read\_buffer(uint8\_t \*buff, uint16\_t len) {
	HAL\_SPI\_Receive(&hspi1, buff, len, HAL_MAX_DELAY);
// while(HAL\_SPI\_Receive\_DMA(&hspi1, buff, len) != HAL\_OK);
}

static void \_\_w5500\_spi\_write\_buffer(uint8\_t \*buff, uint16\_t len) {
	HAL\_SPI\_Transmit(&hspi1, buff, len, HAL_MAX_DELAY);
// while(HAL\_SPI\_Transmit\_IT(&hspi1, buff, len) != HAL\_OK);
}

static uint8\_t \_\_w5500\_read\_byte(void) {
	uint8\_t byte;
	\_\_w5500\_spi\_read\_buffer(&byte, sizeof(byte));
	return byte;
}

static void \_\_w5500\_write\_byte(uint8\_t byte) {
	\_\_w5500\_spi\_write\_buffer(&byte, sizeof(byte));
}

void wiznet\_register(void) {
// First of all, Should register SPI callback functions implemented by user for accessing WIZCHIP
	/\* Critical section callback \*/
	reg\_wizchip\_cris\_cbfunc(__w5500_spi_cris_enter, __w5500_spi_cris_exit); //注册临界区函数
	/\* Chip selection call back \*/
#if \_WIZCHIP\_IO\_MODE\_ == \_WIZCHIP\_IO\_MODE\_SPI\_VDM\_
	reg\_wizchip\_cs\_cbfunc(__w5500_spi_cs_select, __w5500_spi_cs_deselect); //注册SPI片选信号函数
#elif \_WIZCHIP\_IO\_MODE\_ == \_WIZCHIP\_IO\_MODE\_SPI\_FDM\_
    reg\_wizchip\_cs\_cbfunc(SPI_CS_Select, SPI_CS_Deselect);  // CS must be tried with LOW.
#else
    #if (\_WIZCHIP\_IO\_MODE\_ & \_WIZCHIP\_IO\_MODE\_SIP\_) != \_WIZCHIP\_IO\_MODE\_SIP\_
        #error "Unknown \_WIZCHIP\_IO\_MODE\_"
    #else
        reg\_wizchip\_cs\_cbfunc(wizchip_select, wizchip_deselect);
    #endif
#endif
	/\* SPI Read & Write callback function \*/
	reg\_wizchip\_spi\_cbfunc(__w5500_read_byte, __w5500_write_byte);    //注册读写函数

	return;
}
#ifdef W5500\_USE\_STATIC
/\*\*
 \* @brief : w5500\_network\_init
 \* @note : W5500 网络初始化
 \* @param :
 \* @retval :
 \*/
void w5500\_network\_init\_static(void) {

	uint8\_t chipid[6];
	uint8\_t mac[6] = { 0x00, 0x08, 0xdc, 0x11, 0x11, 0x11 }; ///< Source Mac Address
	uint8\_t ip[4] = { 192, 168, 2, 99 }; ///< Source IP Address
	uint8\_t sn[4] = { 255, 255, 255, 0 }; ///< Subnet Mask
	uint8\_t gw[4] = { 192, 168, 2, 1 }; ///< Gateway IP Address
	uint8\_t dns[4] = { 114, 114, 114, 114 }; ///< DNS server IP Address

	memcpy(gWIZNETINFO_STATIC.ip, ip, 4);
	memcpy(gWIZNETINFO_STATIC.sn, sn, 4);
	memcpy(gWIZNETINFO_STATIC.gw, gw, 4);
	memcpy(gWIZNETINFO_STATIC.mac, mac, 6);
	memcpy(gWIZNETINFO_STATIC.dns, dns, 4);
	printf("start init w5500(static)\r\n");
	gWIZNETINFO_STATIC.dhcp = NETINFO_STATIC; //< 1 - Static, 2 - DHCP
	ctlnetwork(CN_SET_NETINFO, (void\*) &gWIZNETINFO_STATIC);

	wizchip\_init(NULL, NULL);

	ctlnetwork(CN_GET_NETINFO, (void\*) &gWIZNETINFO_STATIC);
	// Display Network Information
	ctlwizchip(CW_GET_ID, (void\*) chipid);
	printf("\r\n=== %s NET CONF ===\r\n", (char\*) chipid);
	printf("MAC: %02X:%02X:%02X:%02X:%02X:%02X\r\n", gWIZNETINFO_STATIC.mac[0],
			gWIZNETINFO_STATIC.mac[1], gWIZNETINFO_STATIC.mac[2],
			gWIZNETINFO_STATIC.mac[3], gWIZNETINFO_STATIC.mac[4],
			gWIZNETINFO_STATIC.mac[5]);
	printf("SIP: %d.%d.%d.%d\r\n", gWIZNETINFO_STATIC.ip[0],
			gWIZNETINFO_STATIC.ip[1], gWIZNETINFO_STATIC.ip[2],
			gWIZNETINFO_STATIC.ip[3]);
	printf("GAR: %d.%d.%d.%d\r\n", gWIZNETINFO_STATIC.gw[0],
			gWIZNETINFO_STATIC.gw[1], gWIZNETINFO_STATIC.gw[2],
			gWIZNETINFO_STATIC.gw[3]);
	printf("SUB: %d.%d.%d.%d\r\n", gWIZNETINFO_STATIC.sn[0],
			gWIZNETINFO_STATIC.sn[1], gWIZNETINFO_STATIC.sn[2],
			gWIZNETINFO_STATIC.sn[3]);
	printf("DNS: %d.%d.%d.%d\r\n", gWIZNETINFO_STATIC.dns[0],
			gWIZNETINFO_STATIC.dns[1], gWIZNETINFO_STATIC.dns[2],
			gWIZNETINFO_STATIC.dns[3]);
	printf("======================\r\n");


	printf("w5500 inited\r\n");
}
#endif

#ifdef W5500\_USE\_DHCP
void w5500\_network\_init\_dhcp(void) {
	uint8\_t chipid[6];
	printf("dhcp init w5500(static)\r\n");
	gWIZNETINFO_DHCP.dhcp = NETINFO_DHCP; //< 1 - Static, 2 - DHCP
	ctlnetwork(CN_SET_NETINFO, (void\*) &gWIZNETINFO_DHCP);

// ctlnetwork(CN\_GET\_NETINFO, (void\*) &gWIZNETINFO\_DHCP);
	// Display Network Information
	ctlwizchip(CW_GET_ID, (void\*) chipid);
	wizchip\_init(NULL, NULL);


	DHCP\_init(0, ethBuf0);
	reg\_dhcp\_cbfunc(__w5500_ip_assign, __w5500_ip_assign, __w5500_ip_conflict);

	if (process\_dhcp() == DHCP_IP_LEASED) {
		printf("DHCP Success\r\n");
	} else{
		return;
	}

	ctlnetwork(CN_GET_NETINFO, (void\*) &gWIZNETINFO_DHCP);
	printf("\r\n=== %s NET CONF ===\r\n", (char\*) chipid);
	printf("MAC: %02X:%02X:%02X:%02X:%02X:%02X\r\n", gWIZNETINFO_DHCP.mac[0],
			gWIZNETINFO_DHCP.mac[1], gWIZNETINFO_DHCP.mac[2],
			gWIZNETINFO_DHCP.mac[3], gWIZNETINFO_DHCP.mac[4],
			gWIZNETINFO_DHCP.mac[5]);
	printf("SIP: %d.%d.%d.%d\r\n", gWIZNETINFO_DHCP.ip[0],
			gWIZNETINFO_DHCP.ip[1], gWIZNETINFO_DHCP.ip[2],
			gWIZNETINFO_DHCP.ip[3]);
	printf("GAR: %d.%d.%d.%d\r\n", gWIZNETINFO_DHCP.gw[0],
			gWIZNETINFO_DHCP.gw[1], gWIZNETINFO_DHCP.gw[2],
			gWIZNETINFO_DHCP.gw[3]);
	printf("SUB: %d.%d.%d.%d\r\n", gWIZNETINFO_DHCP.sn[0],
			gWIZNETINFO_DHCP.sn[1], gWIZNETINFO_DHCP.sn[2],
			gWIZNETINFO_DHCP.sn[3]);
	printf("DNS: %d.%d.%d.%d\r\n", gWIZNETINFO_DHCP.dns[0],
			gWIZNETINFO_DHCP.dns[1], gWIZNETINFO_DHCP.dns[2],
			gWIZNETINFO_DHCP.dns[3]);
	printf("======================\r\n");

	printf("w5500 inited\r\n");
}
#endif
//初始化芯片参数
void wiznet\_chip\_config(void) {
	uint8\_t memsize[2][8] = { { 2, 2, 2, 2, 2, 2, 2, 2 }, { 2, 2, 2, 2, 2, 2, 2,
			2 } };

	//WIZCHIP SOCKET缓存区初始化
	if (ctlwizchip(CW_INIT_WIZCHIP, (void\*) memsize) == -1) {
		printf("WIZCHIP Initialized fail.\r\n");
		while (1)
			;
	}
	printf("w5500 chip configured\r\n");
}

#ifdef W5500\_USE\_DHCP
int process\_dhcp(void) {
	int8\_t ret = 0;
	uint8\_t dhcp_retry = 0;
	uint8\_t chipid[6];
	while (1) {
		ret = DHCP\_run();
		if (ret == DHCP_IP_LEASED) {
#ifdef \_MAIN\_DEBUG\_
			printf(" - DHCP Success\r\n");
#endif
			ctlwizchip(CW_GET_ID, (void\*) chipid);
			printf("\r\n=== %s NET CONF ===\r\n", (char\*) chipid);
			printf("MAC: %02X:%02X:%02X:%02X:%02X:%02X\r\n",
					gWIZNETINFO_DHCP.mac[0], gWIZNETINFO_DHCP.mac[1],
					gWIZNETINFO_DHCP.mac[2], gWIZNETINFO_DHCP.mac[3],
					gWIZNETINFO_DHCP.mac[4], gWIZNETINFO_DHCP.mac[5]);
			printf("SIP: %d.%d.%d.%d\r\n", gWIZNETINFO_DHCP.ip[0],
					gWIZNETINFO_DHCP.ip[1], gWIZNETINFO_DHCP.ip[2],
					gWIZNETINFO_DHCP.ip[3]);
			printf("GAR: %d.%d.%d.%d\r\n", gWIZNETINFO_DHCP.gw[0],
					gWIZNETINFO_DHCP.gw[1], gWIZNETINFO_DHCP.gw[2],
					gWIZNETINFO_DHCP.gw[3]);
			printf("SUB: %d.%d.%d.%d\r\n", gWIZNETINFO_DHCP.sn[0],
					gWIZNETINFO_DHCP.sn[1], gWIZNETINFO_DHCP.sn[2],
					gWIZNETINFO_DHCP.sn[3]);
			printf("DNS: %d.%d.%d.%d\r\n", gWIZNETINFO_DHCP.dns[0],
					gWIZNETINFO_DHCP.dns[1], gWIZNETINFO_DHCP.dns[2],
					gWIZNETINFO_DHCP.dns[3]);
			printf("======================\r\n");
			break;
		} else if (ret == DHCP_FAILED) {
			dhcp_retry++;
#ifdef \_MAIN\_DEBUG\_
			if (dhcp_retry <= 3)
				printf(" - DHCP Timeout occurred and retry [%d]\r\n",
						dhcp_retry);
#endif
		}

		if (dhcp_retry > 3) {
#ifdef \_MAIN\_DEBUG\_
			printf(" - DHCP Failed\r\n\r\n");
#endif
			DHCP\_stop();
			break;
		}
		HAL\_Delay(500);
	}
	return ret;
}
#endif


在main.c文件中添加如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/\* Private includes ----------------------------------------------------------\*/
/\* USER CODE BEGIN Includes \*/
#include <stdio.h>
#include "wizchip\_conf.h"
#include "socket.h"
#include "loopback.h"
#include "DHCP/dhcp.h"
#include "w5500\_port.h"
#include <string.h> // memcmp
/\* USER CODE END Includes \*/

int main(void) {
	/\* USER CODE BEGIN 1 \*/

	/\* USER CODE END 1 \*/

	/\* MCU Configuration--------------------------------------------------------\*/

	/\* Reset of all peripherals, Initializes the Flash interface and the Systick. \*/
	HAL\_Init();

	/\* USER CODE BEGIN Init \*/

	/\* USER CODE END Init \*/

	/\* Configure the system clock \*/
	SystemClock\_Config();

	/\* USER CODE BEGIN SysInit \*/

	/\* USER CODE END SysInit \*/

	/\* Initialize all configured peripherals \*/
	MX\_GPIO\_Init();
	MX\_USART1\_UART\_Init();
	MX\_SPI1\_Init();
	/\* USER CODE BEGIN 2 \*/
	printf("-----STM32 W5500 Ethernet Demo-----\r\n");
	w5500\_restart();  // hardware restart through RESET pin
	wiznet\_register();
	w5500\_network\_init\_dhcp();
	wiznet\_chip\_config();
	printf("Init Done!");
	/\* USER CODE END 2 \*/

	/\* Infinite loop \*/
	/\* USER CODE BEGIN WHILE \*/

	/\* USER CODE END 2 \*/

	/\* Infinite loop \*/
	/\* USER CODE BEGIN WHILE \*/
	while (1) {
		/\* USER CODE END WHILE \*/
		//loopback\_tcpc(0, (uint8\_t\*) recv\_buff, destip, destport);
		/\* USER CODE BEGIN 3 \*/
	}
	/\* USER CODE END 3 \*/
}

文章来源: https://iotsmart.blog.csdn.net/article/details/125888128