环境说明：
开发板：某宝买的，STM32F407IG
STM32CUBEMX5.6
: c* T) T  }% [' IHAL Lib Version 1.25

（一）配置时钟
/ }: y+ U* r- F3 b2 a( y2 Q& s' p; E


（二）配置调试串口
1 x8 ~$ F" M4 l( i* u" T6 g
, d) o& Z/ k% `1 i" h$ j
" B& d' F( u- j
（三）配置以太网ETH
% m0 O1 q8 J! A9 ?（1）基础配置
/ N4 j, f+ P; t9 A- ?+ F' n. ?: ?

; j5 d- _/ Z0 z  l
顺序依次说明：
LAN8720A使用的是RMII接口进行配置寄存器
自动重连使能
7 x% c0 Y) n# m3 b) sMAC地址
LAN8720A的物理地址（类似IIC的从设备地址），0或者1，LAN8720A上电后会读取RXER/PHYAD0引脚状态以此来确定设备地址，这里需要根据你自己实际的原理图进行配置，我的原理图是该引脚是悬空的，所以默认就是0。


+ J3 H+ V* t6 h' z
接收模式：可选轮询和中断，我选择了轮询模式。（注：在STM32CUBEMX中如果开启了LWIP那么只能选择轮询模式，实际上是可以使用中断方式的，不过需要自己移植修改lwip协议栈，课参考正点原子）
  s; V% P0 g- Y4 ~( [/ Q1 S; \
( w9 H7 h# z! u* Z8 ^8 A校验：可选软件和硬件，我选择了由硬件去校验

! n0 K. r$ F  f5 F# P8 Y  `& N除此之外还有一个复位引脚ETH_RST，拉低是复位LAN8720A，根据你实际的原理图连线配置该IO为复用输出功能即可。
) a& n8 {/ i# \! t! [/ f" K
+ B, _0 Y9 j+ j8 s1 @（2）高级配置
& F# ~2 p* Q+ Q8 D6 U" A/ C' d

      看下图，此处的配置就是根据实际的PHY芯片寄存器进行配置了，默认的是LAN8742A，而我们使用的是LAN8720A，所以需要更改为 user PHY，配置项默认即可。

  G1 ~% k# n* a- N

/ S3 G, O; z* @( J5 x对于默认配置，我们将默认配置与LAN8720A的数据手册进行对比然后检查是否正确，以PHY Reset这一项为例，默认值是0x8000，去查看数据手册：
9 g$ S/ g/ A- _) M0 c0 E) B

# i0 D" x5 H- k& T7 r/ I
由上图的基本控制寄存器表可知该寄存器偏移地址为0，大小是16位，第15位是软件复位控制，=1是复位，默认为0，那么如果想要复位LAN8720A就需要将该寄存器的第15位置一，也就是0x8000，对比STM32CUBE的默认配置发现一致，其他配置项同理也是这么检查，检查完毕后发现默认配置是OK的。
% L8 e# p, f5 @% j: }5 k$ l: {5 r+ F
$ ]" A: T4 {% m2 {( ^配置LWIP协议栈


& S  x# z& _+ M7 S& |: `* P3 x
" w( E; j1 H# w. O" Q如上图，需要开启状态改变回调函数和连接状态改变回调函数，否则无法实现网线的热拔插。

工程代码修改
文件ethernetif.c中找到函数low_level_init函数，添加复位LAN8720A代码：

. `# i8 }! n# D& e# p

在main函数的主循环中调用函数MX_LWIP_Process。
修改MX_LWIP_Process函数，在其中加入：
" u  Q; B; z0 }# G

7 G/ ~) v2 {/ r$ v, ?6 t
这个函数的作用是检测当前网线的连接状态，如果状态发生改变(例如网线被拔插了一下)，那么就会调用回调函数ethernetif_update_config，看函数名就知道这是更新配置，而这个函数尾部又调用了函数ethernetif_notify_conn_changed，看函数名可知道函数作用是通知连接状态改变，所以我们就更改此函数来达到热拔插自动重连的目的。
! p, X7 ^/ W( o0 N" O4 Y( p
( z# c5 q  m+ W0 S# S
# J& ^, y) s$ t
到此，连接上网线ping测试一下即可。

（四）TCP服务器代码
下面代码的流程是：接收来自客户端的数据->将数据从lwip中拷贝出来->发回去。
0 F, f4 B: L& s1 J- G

1. #if 1
   3 D9 C3 Q3 R7 G. L* m! M
2. 
   , b1 V! S; t: |  E$ p8 m
3. #include <stdio.h>
     E5 O$ |) {% C: \9 J% V+ D0 U0 m
4. #include <string.h>
   8 B/ t9 c8 F$ e5 d( O8 x
5. #include <stdint.h>
   ! @# _, u+ @5 G
6. #include "lwip/tcp.h"
   
7. #include "lwip/err.h"
   
8. #include "lwip/memp.h"
   
9. #include "lwip/inet.h"
   7 O9 }! i+ Q7 H4 u( ]# S
10. 
    : v4 P. i! P+ Q7 u0 |: {
11. 
    
12. / 回调函数控制宏
    
13. #define USE_ERROR_CALLBACK 1
    ' Q. j" Q% o& Q* L
14. #define USE_SENT_CALLBACK 0
    
15. #define USE_POLL_CALLBACK 0
    ! H: m  d+ c8 h: K5 J2 A* t
16. 
    * K7 d3 `# O) x# T, R$ c
17. 
    : J& m7 ~8 h* z; J$ q
18. 
    5 O  m* `; z- [1 T% X
19. / 调试信息输出 //
    
20. #define DEBUG
    
21. 
    
22. #ifdef DEBUG
    
23. #define debug(fmt, ...) do{printf(fmt, ##__VA_ARGS__);}while(0)
    
24. #else
    8 v. ~/ A8 z5 w8 {, y
25. #define debug(fmt, ...) do{;}while(0)
    
26. #endif
    # U# t, a+ h- i
27. 
    - |" {7 y: s9 V8 f1 t) |1 P0 c
28. 
    
29. 
    5 O" {! A- l7 _% Z
30. / tcp接收发送缓存 ///
    " N! g1 L/ L2 B; m
31. #define TCP_RX_LEN  8192
    
32. uint8_t TCP_RX_BUF[TCP_RX_LEN];
    
33. volatile uint16_t TCP_RX_STA = 0;  /* bit15：有无数据标志位        bit14-0:数据量计数 */
    
34. 
    
35. 
    
36. 
    # G1 `  A2 n5 u" |+ R$ {
37. / TCP结构句柄 ///
    * v8 L9 z7 L+ v7 ~' O& W" K
38. struct tcp_pcb* tcppcb = NULL;
    
39. 
    " r: h  O* Z6 V4 x& }8 |, T; \
40. 
    
41. 
    
42. / 本地函数定义 ///
    
43. static void tcp_server_disconnect(struct tcp_pcb *tpcb);
    
44. static uint32_t tcp_server_send(struct tcp_pcb *tpcb, const void* buf, uint32_t len);
    
45. 
    
46. 
    
47. 
    0 o+ c, F, ?2 A
48. / 私有函数实现  ///
    
49. 
    
50. #if (USE_ERROR_CALLBACK == 1)
    3 |: u4 p, X0 \) @% C) d
51. static void error_callback(void *arg, err_t err)
    : L. w$ D' {) s5 x$ M( `( c) @
52. {
    
53.         debug("\r\n error_callback:%d.", err);
    
54. }
    
55. #endif
    
56. 
    
57. #if (USE_ERROR_CALLBACK == 1)
    
58. static void error_callback(void *arg, err_t err)
    , X- D8 s$ E% @
59. {
    2 W9 D2 N+ a+ V5 u# h8 M  `
60.         debug("\r\n error_callback:%d.", err);
    . i1 N0 S3 |% a6 F) {
61.         switch(err)
    
62.         {
    
63.         /* PC上位机如果正常运行中闪退或者不良退出会出现这个错误，此时服务器需要释放掉连接  */
    3 ~+ H9 ~8 i# G% }+ a3 K: j
64.         case ERR_RST:
    
65.         tcp_server_disconnect(tcppcb);
    
66.         break;
    0 y2 G! s$ Y0 B' m4 n8 z
67.         default:break;
    . j% {% D) y' Y  |7 e2 m- h6 X
68.         }
    
69. }
    
70. 
      j& u! @0 Q; W1 ?1 h# Z9 c  ^9 x; P
71. #endif
    
72. 
    
73. static err_t recv_callback(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
    
74. {
    ' E6 I" V: ]+ ?1 O" c# U) i: E
75.         if (p == NULL) /* 接收到空包表示对方断开连接 */
    3 ^4 z) `+ J- Z! F# W
76.         {
    
77.                 tcp_server_disconnect(tpcb);
    ' B; k: `0 X* P4 C; K4 y# ]2 h
78.                 err = ERR_CLSD;
    
79.         }
    
80.         else if (err != ERR_OK) /* 收到非空包但是出现错误 */
    
81.         {
    0 z- Z% ^, h4 D5 K2 p; g
82.                 pbuf_free(p);
    
83.         }
    - X$ a& Q2 R& v/ O) }$ l. |
84.         else /* 接收数据正常，遍历pbuf拷贝出接收到的数据 */
    
85.         {
    ' S0 a& |7 T! i- l8 c- F' T
86.                 struct pbuf* it = p;
    6 }; {1 U$ t( ]) G! y
87. 
    8 Z7 a$ ?9 P9 R: b3 J7 f
88.                 if ((TCP_RX_STA & 0x8000) == 0) /* 当前缓存为空  */
    
89.                 {
    
90.                         for (it = p; it != NULL; it = it->next)
    " q" S7 _3 r2 U8 H3 w# J
91.                         {
    ' Q1 f" O# j! H1 T, l/ a: P
92.                                 if (TCP_RX_STA + it->len > TCP_RX_LEN) /* 缓存满了 */
    - W+ Z8 s( e$ {3 c0 A; w0 i
93.                                         break;
    
94.                                 memcpy(TCP_RX_BUF + TCP_RX_STA, it->payload, it->len);  /* 将接收到的数据拷贝到自己的缓存中  */
    
95.                                 TCP_RX_STA += it->len;
    4 ~2 D  t  D* E+ L
96.                         }
    
97.                         TCP_RX_STA |= 0x8000;    /* 标记有数据收到 */
    7 i/ U3 ]) ~6 z6 x( P$ Z
98.                 }
    . W6 s8 B5 _5 E9 t
99.                 tcp_recved(tpcb, p->tot_len); /* 滑动TCP窗口 */
    
100.                 pbuf_free(p); /* 释放pbuf */
     
101.         }
     2 k; H1 f4 M" b
102.         return err;
     
103. }
     
104. 
     
105. 
     
106. static err_t accept_callback(void *arg, struct tcp_pcb *newpcb, err_t err)
     ( t4 R7 m5 k+ [7 X# `
107. {
     
108.         if (tcppcb == NULL)
     
109.         {
     3 _9 p& v7 a, `: h1 g
110.                 if (err == ERR_OK)
     2 `2 h: u0 L9 w  u2 O8 W* m
111.                 {
     7 e  O4 g9 i* R8 \3 _+ L7 J
112.                         tcppcb = newpcb;
     
113.                         tcp_arg(newpcb, NULL);
     
114.                         tcp_recv(newpcb, recv_callback);
     9 a" o8 f2 v2 j, m1 X
115. 
     
116. #if (USE_ERROR_CALLBACK == 1)
     
117.                         tcp_err(newpcb, error_callback);
     4 X) l  I* \& a; A% i
118. #endif
     ) A1 Z9 X( Y# |( H: m" O
119. 
     3 W% k& v; l8 \# ~* O
120. #if (USE_SENT_CALLBACK == 1)
     
121.                         tcp_sent(newpcb, sent_callback);
     
122. #endif
     
123. 
     8 R8 ^3 T% h8 f. z1 M8 D/ h9 e
124. #if (USE_POLL_CALLBACK == 1)
     
125.                         tcp_poll(newpcb, poll_callback, 1);
     
126. #endif
     
127.                         debug("\r\n %s:%d connect.", inet_ntoa(newpcb->remote_ip), newpcb->remote_port);
     
128.                 }
     4 x9 Z' _; g/ }3 y* T9 |4 B
129.                 else
     
130.                 {
     7 u5 l5 L0 F* X! c* w% v0 @
131.                         tcp_server_disconnect(newpcb);
     0 d8 t6 g' y+ p+ C* _' a" e$ s
132.                 }
     ; l0 r: {' _, G* h6 w# o
133.         }
     
134.         else
     
135.         {
     
136.                 tcp_abort(newpcb);
     
137.                 debug("\r\n already connected. ");
     
138.         }
     
139.         return err;
     / X' f( _0 ^6 {; N- w
140. }
     ! T% S# X$ U+ S  N
141. 
     
142. static void tcp_server_disconnect(struct tcp_pcb *tpcb)
     5 K5 U# A! S* z4 a" |
143. {
     
144.         tcp_arg(tpcb, NULL);
     
145.         tcp_recv(tpcb, NULL);
     
146. 
     
147. #if (USE_SENT_CALLBACK == 1)
     4 C+ i$ c0 e8 D4 G. w. m! J
148.         tcp_sent(tpcb, NULL);
     
149. #endif
     
150. 
     2 U3 n# s0 d7 L$ g
151. #if (USE_POLL_CALLBACK == 1)
     
152.         tcp_poll(tpcb, NULL, 0);
     9 Y% V" E& f$ D1 Y$ ?/ Z
153. #endif
     
154. 
     " ]' }# p8 a- {9 ]! K) j( B" P
155. #if (USE_ERROR_CALLBACK == 1)
     ! X1 U" b7 C" Q) S) h. _7 y" u/ I
156.         tcp_err(tpcb, NULL);
     & P7 V  V9 }) _, y' Y' f" }- j
157. #endif
     
158. 
     7 |6 i5 e+ H3 |  |
159.         tcp_abort(tpcb); /* 关闭连接并释放tpcb控制块 */
     2 U# S; i  i% a9 i  n+ P
160.         tcppcb = NULL;
     8 P: c- j1 L) v! u
161.         debug("\r\n disconnected.");
     
162. }
     & w# L( k& K) w: n, N6 l* x6 F% u
163. 
     3 ~7 W6 ~' c! m0 I
164. static uint32_t tcp_server_send(struct tcp_pcb *tpcb, const void* buf, uint32_t len)
     # t+ K3 f. g1 x
165. {
     % D4 x% @. T8 ~$ _2 |- @3 K
166.         uint32_t nwrite = 0, total = 0;
     
167.         const uint8_t* p = (const uint8_t *) buf;
     1 O1 c& p5 Y% N# O- W& z( j
168.         err_t err = ERR_OK;
     , q5 p' m; [( y- a, a1 i! r# I6 o# n
169.         if (!tpcb)
     
170.                 return 0;
     9 Q$ ~' |, M- T! I0 U, p
171.         while ((err == ERR_OK) && (len != 0) && (tcp_sndbuf(tpcb) > 0))
     
172.         {
     9 W% C7 ?0 y  F
173.                 nwrite = tcp_sndbuf(tpcb) >= len ? len : tcp_sndbuf(tpcb);
     ! V, n  c/ R) o
174.                 err = tcp_write(tpcb, p, nwrite, 1);
     1 i" {7 s. w$ W7 x: P; M+ L
175.                 if (err == ERR_OK)
     # R* w3 k+ a! q$ v$ l) Y7 X" ^( A
176.                 {
     # x5 A% J7 G2 h/ V
177.                         len -= nwrite;
     * o& {) v) }4 \2 n% B+ h( k
178.                         total += nwrite;
     1 x# W- b  W$ ^7 R5 p# L0 ^3 G
179.                         p += nwrite;
     
180.                 }
     
181.                 tcp_output(tpcb);
     ; t- U" V/ D9 v+ U; |
182.         }
     
183.         return total;
     & J0 d' E$ _- @/ e5 c
184. }
     
185. 
     9 g4 S; [& R& D; B+ b
186. / 导出以下函数供外部调用 ///
     ) W$ `2 Z# a6 J6 ?; ]- V( L
187. 
     ! g: O. k4 W  ?) u( k$ z" @  _
188. //extern int tcp_server_start(uint16_t port);
     - r; n6 n) T) J; H
189. //extern int user_senddata(const void* buf,uint32_t len);
     6 y, S- W7 E; J. b: e
190. //extern int transfer_data();
     
191. 
     7 X6 M! s/ a# K
192. 
     
193. /**
     
194. * 启动TCP服务器
     
195. * @param  port 本地端口号
     
196. * @return      成功返回0
     
197. */
     2 G0 {8 g# w0 B# S' T, y
198. int tcp_server_start(uint16_t port)
     
199. {
     
200.         int ret = 0;
     - g3 G" x8 |; }% }$ D7 F; x( K$ @# E
201.         struct tcp_pcb* pcb = NULL;
     
202.         err_t err = ERR_OK;
     
203. 
     
204.         /* create new TCP PCB structure */
     " P1 g5 v$ V- ]1 s6 W
205.         pcb = tcp_new();
     
206.         if (!pcb)
     
207.         {
     . v& Z3 I) D. O- H, x9 F0 `0 M2 n
208.                 debug("Error creating PCB. Out of Memory\n\r");
     
209.                 ret = -1;
     % `: B* g) Q9 A0 `' Z1 T
210.                 goto __exit;
     
211.         }
     
212. 
     
213.         /* bind to specified @port */
     1 d' G7 i4 }- i+ j% _0 K* C5 H
214.         err = tcp_bind(pcb, IP_ADDR_ANY, port);
     
215.         if (err != ERR_OK)
     
216.         {
     
217.                 debug("Unable to bind to port %d: err = %d\n\r", port, err);
     8 {3 V# j; l5 O" i
218.                 ret = -2;
     % w8 e1 G. a# u/ u$ c8 e' v# P
219.                 goto __exit;
     * L1 Z; Q  [4 k
220.         }
     
221. 
     
222.         /* listen for connections */
     
223.         pcb = tcp_listen(pcb);
     9 s: N+ n4 M) O6 B0 ~5 z8 M# Y
224.         if (!pcb)
     8 }+ X! b+ M# e2 _3 Y& q2 c
225.         {
     
226.                 debug("Out of memory while tcp_listen\n\r");
     8 [/ p) J4 @3 o; a% h7 W! Z
227.                 ret = -3;
     
228.         }
     
229. 
     ) E9 @2 f9 i' ~- M* [8 n! ]
230.         /* specify callback to use for incoming connections */
     ' v0 m: _; }6 V2 X5 u8 f2 w
231.         tcp_accept(pcb, accept_callback);
     
232. 
     : {0 u$ ~" t! v$ I7 V0 s* w
233.         /* create success */
     
234.         debug("TCP echo server started @ port %d\n\r", port);
     8 h6 j3 q/ k1 m
235.         return ret;
     6 B7 V0 m' u+ d4 r7 D3 u
236. 
     + ~  s( Z2 z& k5 B5 a0 j8 l/ @7 U
237. __exit:
     
238.         if (pcb)
     3 k6 o1 K3 u/ I* b) Y
239.                 memp_free(MEMP_TCP_PCB, pcb);
     
240.         return ret;
     9 M9 Y5 z5 d- t
241. }
     
242. 
     9 R2 a; F/ w/ E6 B
243. /**
     ! `. d2 P! F. x) I
244. * TCP发送数据
     
245. * @param  buf 待发送的数据
     
246. * @param  len 数据长度
     . M  ?1 k2 M1 ?. C) ]1 K# c
247. * @return     返回实际发送的字节数
     : N$ ?& t$ B5 ]" l! P* B
248. */
     & [, n8 D- m9 P' d( w# J6 G3 u
249. int user_senddata(const void* buf, uint32_t len)
     
250. {
     . U7 `. |6 ~" n* @; j) P
251.         return tcp_server_send(tcppcb, buf, len);
     / y* \  w5 Y0 v. `+ Y4 ~
252. }
     
253. 
     5 k; ?+ c( ~6 x! e
254. /**
     / T) q3 [# C/ H& O& a; r
255. * 轮询函数，放置于main函数的while死循环中
     0 c# O0 t) \$ v' {; v
256. * @return 无
     
257. */
     " |3 i* j) ^  {5 u; u: u9 Z
258. int transfer_data()
     
259. {
     1 ^) B8 Y  @; y7 G. [# @0 V6 g, O
260.         uint32_t nsend = 0;
     7 y; m# ^3 }4 b. P) T7 P
261.         if (tcppcb != NULL && tcppcb->state == ESTABLISHED) /* 连接有效 */
     4 B0 f% M: q) f/ E9 J
262.         {
     ) p( I! w# c3 g: W+ y' Q3 @
263.                 if (TCP_RX_STA & 0x8000)   /* 有数据收到  */
     2 g# ^  I! C# j  z) C% g
264.                 {
     
265.                         nsend = user_senddata(TCP_RX_BUF, TCP_RX_STA & 0x7FFF);    /* 将接收到的数据发回去  */
     / P$ E2 `2 B' I, i8 V% B& p6 B
266.                         TCP_RX_STA = 0;
     
267.                         debug("\r\n send %d bytes success.", nsend);
     7 G& H* t, e. ~3 C* j
268.                 }
     
269.         }
     , O+ v4 S4 O0 S" Y- B& P
270.         return 0;
     5 l* Y) Y6 [) L) ^: R- n
271. }
     
272. 
     ' e0 X5 c3 ?, `- \: M
273. #endif

复制代码

* Z* C$ _; H8 {4 |5 v6 f) @
9 ?4 w" d" A7 R+ _* ^; z

) d1 r: M- m2 i  R3 u6 k