前景描述
我司的以太网实现是LAN8720搭配片上MAC层做的，协议栈用LWIP

这种做法应该还是蛮常见的，反正不是LAN8720就是DP83864，再不然就是硬件协议栈的W5500了
6 `  V3 g: c2 \( c7 O/ Y* h
想想还是有MAC层过滤比较好，随手翻了翻它的手册，W5500好像是没得MAC层过滤的
8 n9 j! w) I/ A" ?
3 b0 P4 F8 w5 R+ v$ s+ t4 n4 S假如数据速率比较高，数据量大，而且外面还有乱七八糟无关的数据往板卡送，我也不知道用这个片子到底好不好

1 [3 x6 {$ }( ILAN8720也不好改了，就继续用吧

  D( i5 o; `& j, y( c6 d4 ~好好在，发给板卡的数据的MAC还是有特征的，我只需要过滤发送方MAC地址的前3个字节，也就是特定的厂家那段
' @1 g. \: s* P* ]
; [" {/ P' E% h) C, e. M( eMAC地址的科普知识这里就不过多描述了，我们直奔主题
& V* H0 g; y& e$ J% B! _& d# `8 o; ^
* q1 X: V2 U1 ]7 \* j3 C1 f怎么用STM32 F7的片上MAC做MAC层过滤
9 |' `( N( B& ?& U, m* s9 U
写这个的目的，就是我搜了搜，没看见有人写这个MAC层过滤功能，具体代码怎么写才能用
) Y+ e+ [( h9 }! O" q4 U" v7 {
$ j# _9 X, N2 Z3 `2 m9 `. H知识科普-STM32的片上MAC
% a& v8 Q% k+ W% E6 k) R5 bSTM32 F7的MAC层过滤方式有三种(说人话的直白解释，中文手册其实也翻译的不好)
精确过滤(手册上叫单播目标/源地址过滤)
- t; h* _5 ~6 H$ l粗糙过滤(手册上叫Hash表过滤)
2 G5 s2 k+ N0 t% e5 P( ~3 g; A特殊过滤(广播，组播过滤等等特殊的过滤)
我这里着重说第1种和第3种
0 P: v: f( @7 i* b) A
' L: D" V4 c9 N' |* Y1 L  y- D4 O2 uSTM32 F7可以存4个MAC地址
其中MAC地址0是自己的MAC，其他三个可以用来做过滤
5 r! @3 ~$ I1 m5 n& K
网络数据包通过PHY进入STM32的MAC，MAC层是可以对目的地址/源地址检查并过滤掉没得用的数据的，默认的HAL库库函数HAL_ETH_Init中
: L. H  h+ \* D# a* e& m# @* C" S有一个static的函数
static void ETH_MACDMAConfig(ETH_HandleTypeDef *heth, uint32_t err)
5 x0 ]2 B. i# m会帮你在初始化网络功能时初始化默认的MAC层功能:
, J1 W! Z1 z$ i8 [; x0 W& |关闭源地址过滤
8 _& d( n1 o9 w' t- N& A不接收所有数据
' f& u  s9 X7 ?接收广播帧
打开目的地地址过滤
/ M% J8 L9 N- v& t, U5 b  [& b单播数据精确过滤
# ^) ~6 g5 ]$ R! x组播数据精确过滤
& I  e5 u( f2 R. }! w4 iHash表过滤关闭

其他的功能自行研究，我这里捡重要的说
8 i9 _! g7 q! P0 T

1. static void ETH_MACDMAConfig(ETH_HandleTypeDef *heth, uint32_t err)
   
2. {
   
3. ETH_MACInitTypeDef macinit;
   
4. ETH_DMAInitTypeDef dmainit;
   
5. uint32_t tmpreg = 0;
   
6. 
   8 C+ t' E" p# ?# Q8 G5 J
7. if (err != ETH_SUCCESS) /* Auto-negotiation failed */
   
8. {
   * }; n4 V$ j5 t5 Y3 z9 Y$ E5 R) i
9. /* Set Ethernet duplex mode to Full-duplex */
   8 m4 A% P+ e; {! z  z% g+ ~
10. (heth->Init).DuplexMode = ETH_MODE_FULLDUPLEX;
    
11. 
    
12. /* Set Ethernet speed to 100M */
    9 C5 r9 V5 q) B+ ^2 J
13. (heth->Init).Speed = ETH_SPEED_100M;
    
14. }
    ( v9 A( ^; B0 |, F" r5 S$ g
15. 
    ; C2 ]+ X- W* T& Z2 U, K8 ]
16. /* Ethernet MAC default initialization **************************************/
    ' S! n! Q! q! R
17. macinit.Watchdog = ETH_WATCHDOG_ENABLE;
    7 h; g, T3 |# ?: T' E) s
18. macinit.Jabber = ETH_JABBER_ENABLE;
    0 x5 Y; q% [5 R' G- U% v
19. macinit.InterFrameGap = ETH_INTERFRAMEGAP_96BIT;
    6 \  f3 I" P$ J
20. macinit.CarrierSense = ETH_CARRIERSENCE_ENABLE;
    
21. macinit.ReceiveOwn = ETH_RECEIVEOWN_ENABLE;
    
22. macinit.LoopbackMode = ETH_LOOPBACKMODE_DISABLE;
    
23. if(heth->Init.ChecksumMode == ETH_CHECKSUM_BY_HARDWARE)
    
24. {
    
25. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_ENABLE;
    
26. }
    
27. else
    
28. {
    
29. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_DISABLE;
    - q& K7 W0 p0 `4 o8 p
30. }
    
31. //这一段是MAC层过滤的设置，下面是DMA的，那个用默认的就可以
    
32. macinit.RetryTransmission = ETH_RETRYTRANSMISSION_DISABLE;
    
33. macinit.AutomaticPadCRCStrip = ETH_AUTOMATICPADCRCSTRIP_DISABLE;
    8 K3 ^6 Z, Z  v- O# t
34. macinit.BackOffLimit = ETH_BACKOFFLIMIT_10;
    
35. macinit.DeferralCheck = ETH_DEFFERRALCHECK_DISABLE;
    0 \" E/ t8 E' e0 H% y
36. macinit.ReceiveAll = ETH_RECEIVEAll_DISABLE;
    
37. macinit.SourceAddrFilter = ETH_SOURCEADDRFILTER_DISABLE;
    0 u/ h8 J2 A0 F; ?/ f* e6 Z
38. macinit.PassControlFrames = ETH_PASSCONTROLFRAMES_BLOCKALL;
    6 W0 c( ?) U  E2 a$ \# R+ R
39. macinit.BroadcastFramesReception = ETH_BROADCASTFRAMESRECEPTION_ENABLE;
    
40. macinit.DestinationAddrFilter = ETH_DESTINATIONADDRFILTER_NORMAL;
    5 Q% v& z$ t$ t5 M
41. macinit.PromiscuousMode = ETH_PROMISCUOUS_MODE_DISABLE;
    & Y& z. Y( j+ M3 V* l0 K
42. macinit.MulticastFramesFilter = ETH_MULTICASTFRAMESFILTER_PERFECT;
    
43. macinit.UnicastFramesFilter = ETH_UNICASTFRAMESFILTER_PERFECT;
    ! C2 M) [$ Z' _8 ^
44. macinit.HashTableHigh = 0x0;
    : u- i- ?& c# ^- F' x6 {" J
45. macinit.HashTableLow = 0x0;
    + c/ h$ d5 d7 j; L
46. macinit.PauseTime = 0x0;
    
47. macinit.ZeroQuantaPause = ETH_ZEROQUANTAPAUSE_DISABLE;
    
48. macinit.PauseLowThreshold = ETH_PAUSELOWTHRESHOLD_MINUS4;
    - r1 J' `# D. Z: w4 x9 u8 f' c7 x0 t
49. macinit.UnicastPauseFrameDetect = ETH_UNICASTPAUSEFRAMEDETECT_DISABLE;
    
50. macinit.ReceiveFlowControl = ETH_RECEIVEFLOWCONTROL_DISABLE;
    
51. macinit.TransmitFlowControl = ETH_TRANSMITFLOWCONTROL_DISABLE;
    ; v4 c5 s. e% O% {, _
52. macinit.VLANTagComparison = ETH_VLANTAGCOMPARISON_16BIT;
    + W$ C) M' ^# b4 I8 M
53. macinit.VLANTagIdentifier = 0x0;
    - g. ]. B; ]" {+ H7 P$ F
54. 
    . `& u0 s* C; |: `$ L6 w
55. /*------------------------ ETHERNET MACCR Configuration --------------------*/
    : u8 z$ Q1 u+ v. R: K
56. /* Get the ETHERNET MACCR value */
    8 ], V' q+ ]) q) e- U
57. tmpreg = (heth->Instance)->MACCR;
    
58. /* Clear WD, PCE, PS, TE and RE bits */
    
59. tmpreg &= ETH_MACCR_CLEAR_MASK;
    
60. /* Set the WD bit according to ETH Watchdog value */
    ( b$ m! J, L5 g+ q! Q. T
61. /* Set the JD: bit according to ETH Jabber value */
    ) Z4 z- j0 N: Q5 \  P. T
62. /* Set the IFG bit according to ETH InterFrameGap value */
    
63. /* Set the DCRS bit according to ETH CarrierSense value */
    
64. /* Set the FES bit according to ETH Speed value */
      t, }8 G# |* d4 L+ O8 p
65. /* Set the DO bit according to ETH ReceiveOwn value */
    ; }% J' T1 D* [5 M6 X7 ]
66. /* Set the LM bit according to ETH LoopbackMode value */
    
67. /* Set the DM bit according to ETH Mode value */
    
68. /* Set the IPCO bit according to ETH ChecksumOffload value */
    8 C$ F4 R, D- ^* F: G; q/ J
69. /* Set the DR bit according to ETH RetryTransmission value */
    $ i) E: H6 A: A( z( L9 Y* t: P9 `
70. /* Set the ACS bit according to ETH AutomaticPadCRCStrip value */
    8 g3 g2 f4 }7 {# r- d/ d% \& B
71. /* Set the BL bit according to ETH BackOffLimit value */
    , [* ^9 X5 e) X9 A
72. /* Set the DC bit according to ETH DeferralCheck value */
    
73. tmpreg |= (uint32_t)(macinit.Watchdog |
    : B; C9 S7 O5 `5 ~
74. macinit.Jabber |
    * S9 O5 |; B1 N( D
75. macinit.InterFrameGap |
    3 G" Z  ]8 i( E
76. macinit.CarrierSense |
    ' K2 H: n8 _& C' E* p
77. (heth->Init).Speed |
    
78. macinit.ReceiveOwn |
    7 ?& k$ W4 m! u0 \
79. macinit.LoopbackMode |
    
80. (heth->Init).DuplexMode |
    6 @/ ~7 j0 f5 A
81. macinit.ChecksumOffload |
    * k% k, p( E- V/ @; b  R2 ]6 R
82. macinit.RetryTransmission |
    ; {, D" _9 J; R
83. macinit.AutomaticPadCRCStrip |
    $ \5 Z, T5 y$ }- F) c
84. macinit.BackOffLimit |
    ) ^' r4 p9 `/ c) F# }
85. macinit.DeferralCheck);
    & ]  [) ]9 w& \! R# ~6 Q
86. 
    
87. /* Write to ETHERNET MACCR */
    
88. (heth->Instance)->MACCR = (uint32_t)tmpreg;
    
89. 
    
90. /* Wait until the write operation will be taken into account:
    
91. at least four TX_CLK/RX_CLK clock cycles */
    
92. tmpreg = (heth->Instance)->MACCR;
    ( e8 A2 A' t( C$ j1 X  B
93. HAL_Delay(ETH_REG_WRITE_DELAY);
    0 D& d  O  z0 T$ W& ?& r( q
94. (heth->Instance)->MACCR = tmpreg;
    - \  L) |. `  w1 J7 W
95. 
    
96. /*----------------------- ETHERNET MACFFR Configuration --------------------*/
    6 p6 {/ p. q% d" _+ `6 W0 W; z
97. /* Set the RA bit according to ETH ReceiveAll value */
    3 R6 Y1 O( j# i% A# b2 _
98. /* Set the SAF and SAIF bits according to ETH SourceAddrFilter value */
    
99. /* Set the PCF bit according to ETH PassControlFrames value */
    
100. /* Set the DBF bit according to ETH BroadcastFramesReception value */
     : t  w8 s: i$ }: B% ?2 z+ C9 k
101. /* Set the DAIF bit according to ETH DestinationAddrFilter value */
     9 C4 K) |  B0 g* N7 Y( Z' d, g
102. /* Set the PR bit according to ETH PromiscuousMode value */
     / k9 e( E3 r* u" P- m! k5 H0 g
103. /* Set the PM, HMC and HPF bits according to ETH MulticastFramesFilter value */
     - k' b9 W: }/ V6 O! r
104. /* Set the HUC and HPF bits according to ETH UnicastFramesFilter value */
     
105. /* Write to ETHERNET MACFFR */
     
106. (heth->Instance)->MACFFR = (uint32_t)(macinit.ReceiveAll |
     ( ]! [8 {" h4 N& H
107. macinit.SourceAddrFilter |
     8 G( }5 ^7 B2 O  {! H: K" A. Z
108. macinit.PassControlFrames |
     
109. macinit.BroadcastFramesReception |
     
110. macinit.DestinationAddrFilter |
     
111. macinit.PromiscuousMode |
     / A6 G2 t  p, x3 ?6 y+ S& }
112. macinit.MulticastFramesFilter |
     
113. macinit.UnicastFramesFilter);
     % J: q9 {2 q4 F0 c/ B
114. 
     
115. /* Wait until the write operation will be taken into account:
     
116. at least four TX_CLK/RX_CLK clock cycles */
     % I! g7 b6 c6 t& K/ L' T' m. {; {
117. tmpreg = (heth->Instance)->MACFFR;
     - m! L5 G" h% _5 r
118. HAL_Delay(ETH_REG_WRITE_DELAY);
     1 w: K+ G: O2 h8 R$ G8 K$ k
119. (heth->Instance)->MACFFR = tmpreg;
       \2 n- g% M- H. I
120. 
     & F% R9 J% y9 z1 ?5 S! c
121. /*--------------- ETHERNET MACHTHR and MACHTLR Configuration --------------*/
     * s, U  F3 a+ x
122. /* Write to ETHERNET MACHTHR */
     
123. (heth->Instance)->MACHTHR = (uint32_t)macinit.HashTableHigh;
     . F( d  `8 D0 @
124. 
     1 \6 o1 V7 C! m" P$ H- }; c+ r" Y+ K& q
125. /* Write to ETHERNET MACHTLR */
     
126. (heth->Instance)->MACHTLR = (uint32_t)macinit.HashTableLow;
     
127. /*----------------------- ETHERNET MACFCR Configuration -------------------*/
     2 s" g/ Z% ^6 L5 H+ g" B! Y: V! j
128. 
     6 F' t5 d# t+ A2 S: `
129. /* Get the ETHERNET MACFCR value */
     
130. tmpreg = (heth->Instance)->MACFCR;
     9 g' O' N; C; F3 ]7 @
131. /* Clear xx bits */
     
132. tmpreg &= ETH_MACFCR_CLEAR_MASK;
     
133. 
     
134. /* Set the PT bit according to ETH PauseTime value */
     
135. /* Set the DZPQ bit according to ETH ZeroQuantaPause value */
     
136. /* Set the PLT bit according to ETH PauseLowThreshold value */
     
137. /* Set the UP bit according to ETH UnicastPauseFrameDetect value */
     
138. /* Set the RFE bit according to ETH ReceiveFlowControl value */
     7 C) A( ]! C$ D$ n: C
139. /* Set the TFE bit according to ETH TransmitFlowControl value */
     
140. tmpreg |= (uint32_t)((macinit.PauseTime Instance)->MACFCR = (uint32_t)tmpreg;
     & ]5 |- e* a$ o* c4 c$ m4 A
141. 
     
142. /* Wait until the write operation will be taken into account:
     
143. at least four TX_CLK/RX_CLK clock cycles */
     + w3 X" {6 k5 @' I& u4 i) M
144. tmpreg = (heth->Instance)->MACFCR;
     
145. HAL_Delay(ETH_REG_WRITE_DELAY);
     
146. (heth->Instance)->MACFCR = tmpreg;
     
147. 
     
148. /*----------------------- ETHERNET MACVLANTR Configuration ----------------*/
     
149. /* Set the ETV bit according to ETH VLANTagComparison value */
     
150. /* Set the VL bit according to ETH VLANTagIdentifier value */
     
151. (heth->Instance)->MACVLANTR = (uint32_t)(macinit.VLANTagComparison |
     ' C' R8 T$ |7 o3 w2 m8 G  S1 D  M
152. macinit.VLANTagIdentifier);
     
153. 
     * ]" N4 L1 ^0 E. s1 S1 V1 |+ }
154. /* Wait until the write operation will be taken into account:
     
155.    at least four TX_CLK/RX_CLK clock cycles */
     ! m1 F5 ]% j6 f6 k4 K
156. tmpreg = (heth->Instance)->MACVLANTR;
     
157. HAL_Delay(ETH_REG_WRITE_DELAY);
     2 K. r7 K- y1 b
158. (heth->Instance)->MACVLANTR = tmpreg;
     
159. 
     * n7 ^* l5 l- v2 @) J2 u/ p# x/ ~
160. /* Ethernet DMA default initialization ************************************/
     , {" |6 Y- [& l
161. dmainit.DropTCPIPChecksumErrorFrame = ETH_DROPTCPIPCHECKSUMERRORFRAME_ENABLE;
     5 Y& M& c6 F9 }* o! d$ f1 a
162. dmainit.ReceiveStoreForward = ETH_RECEIVESTOREFORWARD_ENABLE;
     % d- |% o  e, ?5 v# X" ?' O) Y  A
163. dmainit.FlushReceivedFrame = ETH_FLUSHRECEIVEDFRAME_ENABLE;
     
164. dmainit.TransmitStoreForward = ETH_TRANSMITSTOREFORWARD_ENABLE;
     
165. dmainit.TransmitThresholdControl = ETH_TRANSMITTHRESHOLDCONTROL_64BYTES;
     
166. dmainit.ForwardErrorFrames = ETH_FORWARDERRORFRAMES_DISABLE;
     0 [$ s  E- Y& B1 r
167. dmainit.ForwardUndersizedGoodFrames = ETH_FORWARDUNDERSIZEDGOODFRAMES_DISABLE;
     ! ^  v8 W. j2 O4 v: p# h
168. dmainit.ReceiveThresholdControl = ETH_RECEIVEDTHRESHOLDCONTROL_64BYTES;
     
169. dmainit.SecondFrameOperate = ETH_SECONDFRAMEOPERARTE_ENABLE;
     
170. dmainit.AddressAlignedBeats = ETH_ADDRESSALIGNEDBEATS_ENABLE;
     + T" P+ h# `! |- n# f
171. dmainit.FixedBurst = ETH_FIXEDBURST_ENABLE;
     
172. dmainit.RxDMABurstLength = ETH_RXDMABURSTLENGTH_32BEAT;
     ) y% c' z2 W3 t* G0 R! ?8 ~2 C+ i
173. dmainit.TxDMABurstLength = ETH_TXDMABURSTLENGTH_32BEAT;
     
174. dmainit.EnhancedDescriptorFormat = ETH_DMAENHANCEDDESCRIPTOR_ENABLE;
     4 W  f1 a* F  r0 u  q+ X. x
175. dmainit.DescriptorSkipLength = 0x0;
     7 F& j4 K; T7 ~+ b$ `/ I6 _. ~: U
176. dmainit.DMAArbitration = ETH_DMAARBITRATION_ROUNDROBIN_RXTX_1_1;
     ; V, F& K  \, I3 b" S
177. 
     7 Y' F1 B' F! c- v; E
178. /* Get the ETHERNET DMAOMR value */
     6 u' I) D, l4 F
179. tmpreg = (heth->Instance)->DMAOMR;
     1 g# P9 q/ x3 y; |# d: {
180. /* Clear xx bits */
     5 m, D5 S  Z; x- s
181. tmpreg &= ETH_DMAOMR_CLEAR_MASK;
     3 y7 p( A( d( [% i8 y
182. 
     , A! M" T7 P# \: F( H$ o0 P
183. /* Set the DT bit according to ETH DropTCPIPChecksumErrorFrame value */
     ) ]/ Q! k% B0 P0 c
184. /* Set the RSF bit according to ETH ReceiveStoreForward value */
     
185. /* Set the DFF bit according to ETH FlushReceivedFrame value */
     ! {& n4 W( h3 s& o8 C- S6 ^' Q; U, T
186. /* Set the TSF bit according to ETH TransmitStoreForward value */
     $ C- z/ E: u, m8 [% r
187. /* Set the TTC bit according to ETH TransmitThresholdControl value */
     6 K! _/ A$ M$ ~) U- b# b: {* d
188. /* Set the FEF bit according to ETH ForwardErrorFrames value */
     
189. /* Set the FUF bit according to ETH ForwardUndersizedGoodFrames value */
     
190. /* Set the RTC bit according to ETH ReceiveThresholdControl value */
     3 l* K) u( Y8 ]$ J: p$ I' H0 R1 n7 X
191. /* Set the OSF bit according to ETH SecondFrameOperate value */
     
192. tmpreg |= (uint32_t)(dmainit.DropTCPIPChecksumErrorFrame |
     3 F0 \& Y- v0 c0 l0 ]* r' e9 G
193.                      dmainit.ReceiveStoreForward |
     ; Y& A! E0 M+ T
194.                      dmainit.FlushReceivedFrame |
     
195.                      dmainit.TransmitStoreForward |
     % K8 e( s  O2 Z, |5 h* t6 Z- }
196.                      dmainit.TransmitThresholdControl |
     5 ]% s5 g: g+ ]9 O
197.                      dmainit.ForwardErrorFrames |
     
198.                      dmainit.ForwardUndersizedGoodFrames |
     " H: R. i# ]! l7 F# X6 g- u, A
199.                      dmainit.ReceiveThresholdControl |
     
200.                      dmainit.SecondFrameOperate);
     
201. 
     
202. /* Write to ETHERNET DMAOMR */
     
203. (heth->Instance)->DMAOMR = (uint32_t)tmpreg;
     
204. 
     
205. /* Wait until the write operation will be taken into account:
     
206.    at least four TX_CLK/RX_CLK clock cycles */
     
207. tmpreg = (heth->Instance)->DMAOMR;
     
208. HAL_Delay(ETH_REG_WRITE_DELAY);
     
209. (heth->Instance)->DMAOMR = tmpreg;
     
210. 
     
211. /*----------------------- ETHERNET DMABMR Configuration ------------------*/
     
212. /* Set the AAL bit according to ETH AddressAlignedBeats value */
     # d3 f6 J$ ]; g
213. /* Set the FB bit according to ETH FixedBurst value */
     
214. /* Set the RPBL and 4*PBL bits according to ETH RxDMABurstLength value */
     ! i$ ]5 \* s& K- `
215. /* Set the PBL and 4*PBL bits according to ETH TxDMABurstLength value */
     
216. /* Set the Enhanced DMA descriptors bit according to ETH EnhancedDescriptorFormat value*/
     6 k, e, F9 @- v" _2 d3 V1 B# k6 z/ o7 P
217. /* Set the DSL bit according to ETH DesciptorSkipLength value */
     ) E9 G2 n2 t5 Z, |
218. /* Set the PR and DA bits according to ETH DMAArbitration value */
     
219. (heth->Instance)->DMABMR = (uint32_t)(dmainit.AddressAlignedBeats |
     2 D% b( C, f* b! S! x
220.                                       dmainit.FixedBurst |
     
221.                                       dmainit.RxDMABurstLength |    /* !! if 4xPBL is selected for Tx or Rx it is applied for the other */
     . I$ e, b8 ~6 L/ U
222.                                       dmainit.TxDMABurstLength |
     
223.                                       dmainit.EnhancedDescriptorFormat |
     2 T$ h$ C+ R4 p6 o
224.                                       (dmainit.DescriptorSkipLength Instance)->DMABMR;
     
225. HAL_Delay(ETH_REG_WRITE_DELAY);
     % c) a" ?: V& K/ h% d  F7 W
226. (heth->Instance)->DMABMR = tmpreg;
     
227. 
     
228. if((heth->Init).RxMode == ETH_RXINTERRUPT_MODE)
     
229. {
     : x6 F0 {2 ]/ r) x
230.    /* Enable the Ethernet Rx Interrupt */
     ' `3 ~. V- a0 E5 S( V
231.    __HAL_ETH_DMA_ENABLE_IT((heth), ETH_DMA_IT_NIS | ETH_DMA_IT_R);
     
232. }
     2 H: q) q- l5 Y0 j( y
233. 
     2 _  R/ V5 {( n
234. /* Initialize MAC address in ethernet MAC */
     & }. T# c4 m* q/ T% r# t- R/ k
235. ETH_MACAddressConfig(heth, ETH_MAC_ADDRESS0, heth->Init.MACAddr);
     
236. }

复制代码

" e/ Y  _. W% g这里我就要稍微吐槽一下HAL库了
; }- }7 P# z. v2 w$ DMAC层过滤的设置没有预留接口出来，有设置MAC地址的函数

static void ETH_MACAddressConfig(ETH_HandleTypeDef *heth, uint32_t MacAddr, uint8_t *Addr)
' h2 P7 D0 ?3 }4 Y; K% I
$ j. E0 O8 }* c4 w7 l! r就不多做一个设置MAC层过滤的函数嘛，连后面用到的宏定义都有~~
, P" ]$ f, v0 J$ P
( A3 i4 `) F) k/ w( o8 F木有办法，自己编一个初始化MAC层过滤的函数吧

其实也就是把上面这个ETH_MACDMAConfig函数分离成两个单独的设置函数，再编一个设置MAC层过滤的函数
# j  m, a1 {% f( T/ H
& n; d* @$ I' k" C! \; J+ k开启MAC层过滤的初始化代码
5 J3 F) _, Y; F* y/ C+ |

1. uint8_t ETH_MAC_Setting(ETH_HandleTypeDef *heth)
   - a, i8 }* O/ A7 r& V% C) E. V  H* s
2. {
   
3. ETH_MACInitTypeDef macinit;
   
4. /* Ethernet MAC default initialization **************************************/
   ( x  y, n1 T; E  H+ T& W% t1 ~/ \" D
5. macinit.Watchdog = ETH_WATCHDOG_ENABLE;
   " ^: _5 ~/ J( g- ~: R; I
6. macinit.Jabber = ETH_JABBER_ENABLE;
   / r: t+ h: z* q+ Q) s& C# Q5 s
7. macinit.InterFrameGap = ETH_INTERFRAMEGAP_96BIT;
   
8. macinit.CarrierSense = ETH_CARRIERSENCE_ENABLE;
   # p5 |/ g3 t, i. H
9. macinit.ReceiveOwn = ETH_RECEIVEOWN_ENABLE;
   ; t4 }, `5 i1 }6 {7 L
10. macinit.LoopbackMode = ETH_LOOPBACKMODE_DISABLE;
    
11. if (heth->Init.ChecksumMode == ETH_CHECKSUM_BY_HARDWARE)
    
12. {
    
13. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_ENABLE;
    ( Z% \2 ~: }2 h6 f- p
14. }
    
15. else
    
16. {
    4 r) B! h2 e* S  t! o9 B
17. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_DISABLE;
    $ h: M5 [8 y' x" B/ G: @
18. }
    
19. macinit.RetryTransmission = ETH_RETRYTRANSMISSION_ENABLE;          //使能重传
    
20. macinit.AutomaticPadCRCStrip = ETH_AUTOMATICPADCRCSTRIP_ENABLE;          //使能自动去除
    
21. macinit.BackOffLimit = ETH_BACKOFFLIMIT_10;
    
22. macinit.DeferralCheck = ETH_DEFFERRALCHECK_DISABLE;
    
23. macinit.ReceiveAll = ETH_RECEIVEAll_DISABLE; ///不接收所有包
    
24. macinit.SourceAddrFilter = ETH_SOURCEADDRFILTER_NORMAL_ENABLE; //源地址过滤
    ; G1 N" ]) N' c  r$ l' n
25. macinit.PassControlFrames = ETH_PASSCONTROLFRAMES_BLOCKALL;
    
26. macinit.BroadcastFramesReception = ETH_BROADCASTFRAMESRECEPTION_DISABLE; //广播不接收
    7 `' g6 n7 x) j2 Z, J- {2 W/ h
27. macinit.DestinationAddrFilter = ETH_DESTINATIONADDRFILTER_NORMAL; //目的地址过滤
    
28. macinit.PromiscuousMode = ETH_PROMISCUOUS_MODE_DISABLE; //混乱模式
    
29. macinit.MulticastFramesFilter = ETH_MULTICASTFRAMESFILTER_PERFECT; //多播过滤
    
30. macinit.UnicastFramesFilter = ETH_UNICASTFRAMESFILTER_PERFECT; //单播过滤
    8 e4 }0 x3 y( E( O) ^
31. macinit.HashTableHigh = 0x0; //Hash表高位
    
32. macinit.HashTableLow = 0x0; //Hash表低位
    . N+ b4 A9 A# i2 o  ?+ a% C% [) w) h* t
33. macinit.PauseTime = 0x0;
    
34. macinit.ZeroQuantaPause = ETH_ZEROQUANTAPAUSE_DISABLE;
    # u+ H& `  m* [3 S0 q( l! f9 K
35. macinit.PauseLowThreshold = ETH_PAUSELOWTHRESHOLD_MINUS4;
    
36. macinit.UnicastPauseFrameDetect = ETH_UNICASTPAUSEFRAMEDETECT_ENABLE;
    
37. macinit.ReceiveFlowControl = ETH_RECEIVEFLOWCONTROL_DISABLE; //接收流控
    
38. macinit.TransmitFlowControl = ETH_TRANSMITFLOWCONTROL_DISABLE; //发送流控
    0 p: U3 g5 W9 O, R) ^
39. macinit.VLANTagComparison = ETH_VLANTAGCOMPARISON_16BIT;
    % ^9 A' p4 a# w, R; O
40. macinit.VLANTagIdentifier = 0x0;
    : ~+ ~5 V& L- A7 _- ^
41. 
    
42. return HAL_ETH_ConfigMAC(heth, &macinit);
    
43. }

复制代码

默认的MAC层 DMA初始化函数

1. uint8_t ETH_DMA_Setting(ETH_HandleTypeDef *heth)
   0 V+ I, R: e  x+ D3 |! e4 p' {' E$ t
2. {
   
3. ETH_DMAInitTypeDef dmainit;
   ( C% Z+ g; n! r' O( K
4. /* Ethernet DMA default initialization ************************************/
   9 t  c2 T: J0 I: {
5. dmainit.DropTCPIPChecksumErrorFrame = ETH_DROPTCPIPCHECKSUMERRORFRAME_ENABLE;
   
6. dmainit.ReceiveStoreForward = ETH_RECEIVESTOREFORWARD_ENABLE;
   + j. |" T% l. L: K
7. dmainit.FlushReceivedFrame = ETH_FLUSHRECEIVEDFRAME_ENABLE;
   $ F4 T5 \! R; e+ _; [
8. dmainit.TransmitStoreForward = ETH_TRANSMITSTOREFORWARD_ENABLE;
   
9. dmainit.TransmitThresholdControl = ETH_TRANSMITTHRESHOLDCONTROL_64BYTES;
   
10. dmainit.ForwardErrorFrames = ETH_FORWARDERRORFRAMES_DISABLE;
    
11. dmainit.ForwardUndersizedGoodFrames = ETH_FORWARDUNDERSIZEDGOODFRAMES_DISABLE;
    $ E- S# c7 F6 T! I. S
12. dmainit.ReceiveThresholdControl = ETH_RECEIVEDTHRESHOLDCONTROL_64BYTES;
    
13. dmainit.SecondFrameOperate = ETH_SECONDFRAMEOPERARTE_ENABLE;
    " V! b3 l4 t9 y% n6 }
14. dmainit.AddressAlignedBeats = ETH_ADDRESSALIGNEDBEATS_ENABLE;
    
15. dmainit.FixedBurst = ETH_FIXEDBURST_ENABLE;
    
16. dmainit.RxDMABurstLength = ETH_RXDMABURSTLENGTH_32BEAT;
    
17. dmainit.TxDMABurstLength = ETH_TXDMABURSTLENGTH_32BEAT;
    + r/ j+ @# X' Y  `, m; Q2 c' f
18. dmainit.EnhancedDescriptorFormat = ETH_DMAENHANCEDDESCRIPTOR_ENABLE;
    3 W' @- b, V7 A% R
19. dmainit.DescriptorSkipLength = 0x0;
    
20. dmainit.DMAArbitration = ETH_DMAARBITRATION_ROUNDROBIN_RXTX_1_1;
    
21. uint8_t res =  HAL_ETH_ConfigDMA(heth, &dmainit);
    
22. if ((heth->Init).RxMode == ETH_RXINTERRUPT_MODE)
    8 H4 H" f! B$ `8 N' I0 ?
23. {
    ( D0 o% q& `; c$ e& R
24. /* Enable the Ethernet Rx Interrupt */
    
25. __HAL_ETH_DMA_ENABLE_IT((heth), ETH_DMA_IT_NIS | ETH_DMA_IT_R);
    7 g2 s! g0 F6 [: x! `
26. }
    9 b( e$ `. V: Y
27. return res;
    4 Z6 K7 p8 V- B* @  N$ v/ X
28. }

复制代码

用来设置MAC地址的函数(其实就是把库函数的static函数取出来直接用了)

1. <blockquote>//heth: HAL句柄

复制代码

$ p2 @5 `, B6 ~9 a( {5 x然后到最最重要的MAC层过滤设置
1 X3 Y2 z7 B+ d( L# B以MAC1为例
7 l3 b' x5 n7 F" S5 E2 o4 M" L

: d. P% t% D( Y. O. c3 Z9 m

注意看红框的描述
4 L% I8 T& A: {2 H% a功能很好用，可以过滤源地址/目的地址，还可以做掩码功能
设置MAC层过滤的代码

1. static void ETH_MAC_Filter_Setting(ETH_HandleTypeDef *heth,ST_ETH_PAR * para)
   
2. {
   
3.     //设置本机MAC地址
   
4.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS0, heth->Init.MACAddr);
   ) M, F/ }9 H( G; X- p/ A! D
5.     //设置UDP-A的对方MAC地址
   1 T4 k, I9 Y/ I, p# `7 P
6.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS1,para->UDP_A_MAC);
   
7.     (heth->Instance)->MACA1HR|=0xC0000000;//需要完全匹配UDP-A的对方MAC才接收
   7 M/ ~2 d" Z- j
8.     //设置UDP-B的对方MAC地址
   0 }; R+ c- T1 ]- z: W; p
9.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS2,para->UDP_B_MAC);
   
10.     (heth->Instance)->MACA2HR|=0xC0000000;//需要完全匹配UDP-A的对方MAC才接收
    " o" T5 X! z3 G9 u6 h, \
11. }

复制代码

, n! I7 ?6 U2 i& B3 {! H我这里是希望为我的两个UDP精确过滤接收到的源地址
5 X9 T5 D( D/ o0 g6 m所以AE位设置为1，SA设置为1，MBC全部为0(MAC地址全部检查)

# d' E  W  Q* [$ a2 D- D& ?假如我希望过滤MAC中特定的厂家字段
# A0 `% k8 p3 q( w5 U1 C, _例如某个MAC地址
  H5 U; o; M. \9 w01-02-03-04-05-06
其中01-02-03就是厂家字段
0 l6 T* N. {+ D% K& C8 S7 L) H
那么代码要这样修改（MBC的第29位，28位，27位置1）
* p' @3 B; d: A0 ]' a2 ^) k这样MAC层就不会检查MAC地址里后3个字节(04-05-06)
但是会检查前3个字节，也就是厂家字段
0 u. W# e4 C( y/ j1 r这里需要注意MAC地址的字节序
! _9 D: `2 G3 W; J2 E+ J

1. static void ETH_MAC_Filter_Setting(ETH_HandleTypeDef *heth,ST_ETH_PAR * para)
   , _! T+ i8 L" G- p0 G& [
2. {
     {$ g7 z8 D' r9 m- T0 V1 P
3.     //设置本机MAC地址
   : s# N2 \# W1 v
4.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS0, heth->Init.MACAddr);
   
5.     //设置UDP-A的对方MAC地址
   ( p9 x5 V+ O! M# A3 U- S
6.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS1,para->UDP_A_MAC);
   " x; n$ j, g7 K) S3 a6 h4 {9 g
7.     (heth->Instance)->MACA1HR|=0xF8000000;//需要匹配厂家字段
   
8.     //设置UDP-B的对方MAC地址
   . D7 b0 i+ Z2 J& e
9.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS2,para->UDP_B_MAC);
   
10.     (heth->Instance)->MACA2HR|=0xF8000000;//需要匹配厂家字段
    7 }, [; U5 v" y/ }0 ?
11. }

复制代码

然后这些函数的调用顺序按:
1. HAL_ETH_Init
/ V% u* L4 Q: l: X7 c- c2. ETH_MAC_Setting
3. ETH_DMA_Setting
4. ETH_MAC_Filter_Setting

用你希望过滤的MAC传递到一个Hash计算函数里，得到一个值，通过这个值产生“映射”关系来过滤MAC地址，所以这个并不是精确的，因为可能会重复~~

* {1 u, G' h3 \+ a9 X3 zHASH函数
函数

1. / STM32 MACHASH - Copyright (C) 2014-2018 Clive Turvey (<a href="mailto:sourcer32@gmail.com">sourcer32@gmail.com</a>)
   
2. //  All Rights Reserved
   
3. 
   / Q5 [8 d: |* z  N! ~* Z# H. b
4. #include <windows.h>
   
5. 
   
6. #include <stdio.h>
   4 A; Y9 O& l; W; p! }, C
7. #include <stdlib.h>
   
8. 
   & x) ]% u+ B) ^  P- I
9. typedef unsigned char uint8_t;
   
10. typedef unsigned long uint32_t;
    6 ^" Z  i8 B6 Z. p$ v0 c2 A
11. 
    ) U# D0 |' B' X# [  x0 }" F0 v
12. uint32_t Rev32(uint32_t x)
    
13. {
    7 `9 m. V/ z4 [- k( }$ W
14.   uint32_t y;
    ! n; r- r9 }) \; f
15.   int i;
    * B& Z, Y3 V" ^3 W
16. 
    ) [: s& r- X" h6 v9 P" ?, X
17.   y = 0;
    + b  j. k6 U. ~7 L0 |* r  [
18. 
    : w8 {  A/ h# X7 p0 z
19.   for(i=0; i<32; i++)
    
20.     if (x & (1 << i))
    
21.       y |= 1 << (31 - i);
    
22. 
    , k2 V% B; m7 l$ P4 A
23.   return(y);
    # {$ B# o* _* P/ [6 c, E
24. }
    , L+ v7 A- _+ w8 U3 o* D
25. 
    ( b, N+ v' t% n$ o, s* f3 R- z
26. uint32_t MacHash(const uint8_t *Mac) // <a href="mailto:sourcer32@gmail.com">sourcer32@gmail.com</a>
    
27. {
    $ Q- t/ T: `% }
28.   int i, j;
    
29.   uint32_t Crc;
    
30. 
    ! F7 G: N- r" I8 U4 c8 `$ r
31.   Crc = 0xFFFFFFFF;
    
32. 
    
33.   for(j=0; j<6; j++)
    7 I% d$ ~% V7 C$ o" C+ h: O) c9 Z
34.   {
    + y7 X, k2 {* s$ P% v
35.     Crc = Crc ^ (uint32_t)Mac[j];
    
36. 
    4 J6 e- m' A9 e- O& Y: g
37.     for(i=0; i<8; i++)
    
38.       if (Crc & 1)
    0 K8 a) Y9 X  M- y7 j1 W7 O* C) v
39.         Crc = (Crc >> 1) ^ 0xEDB88320; // Reversed 0x04C11DB7
    
40.       else
    " J; A& A# d7 t2 S) X  Q9 r
41.         Crc = (Crc >> 1);
    0 M( |% F5 N! n8 ^9 ~' B1 E( W
42.   }
    , H. K. d2 w# T' R, v8 Z6 a
43. 
    
44.   return(Rev32(~Crc) >> 26); // Get High order 6-bit in reversed/inverted CRC
    1 D- x7 ~8 M( x5 P# M2 h
45. }
    
46. 
    
47. uint32_t MacHashFast(const uint8_t *Mac) // <a href="mailto:sourcer32@gmail.com">sourcer32@gmail.com</a>
    2 P6 t5 A3 p7 v* b) |  `# O+ N
48. {
    
49.   static const uint32_t Rev6Tbl[] = {
    
50.     0x00,0x20,0x10,0x30,0x08,0x28,0x18,0x38,
    
51.     0x04,0x24,0x14,0x34,0x0C,0x2C,0x1C,0x3C,
    
52.     0x02,0x22,0x12,0x32,0x0A,0x2A,0x1A,0x3A,
    - |  `. x" m  s. c  g5 k5 ~; ~: F
53.     0x06,0x26,0x16,0x36,0x0E,0x2E,0x1E,0x3E,
    
54.     0x01,0x21,0x11,0x31,0x09,0x29,0x19,0x39,
    
55.     0x05,0x25,0x15,0x35,0x0D,0x2D,0x1D,0x3D,
    6 X9 R+ c' x  W
56.     0x03,0x23,0x13,0x33,0x0B,0x2B,0x1B,0x3B,
    * o5 ~# z' `1 _" O
57.     0x07,0x27,0x17,0x37,0x0F,0x2F,0x1F,0x3F };
    
58. 
    # U1 b5 ]* m0 c! t- s9 n. m
59.   static const uint32_t Crc32Tbl[] = {
    # t+ ]7 s% D; i0 U
60.     0x4DBDF21C, 0x500AE278, 0x76D3D2D4, 0x6B64C2B0,
    . j6 Q9 |) T& _
61.     0x3B61B38C, 0x26D6A3E8, 0x000F9344, 0x1DB88320,
    1 B; Y8 u4 t6 Q( g. z+ o8 N
62.     0xA005713C, 0xBDB26158, 0x9B6B51F4, 0x86DC4190,
    / d) u3 E6 b2 f, I8 F. ^) n
63.     0xD6D930AC, 0xCB6E20C8, 0xEDB71064, 0xF0000000 };
    
64. 
    6 F  S2 h4 |! y$ s4 [
65.   int i;
    % A/ A- Q  Z+ V. g/ t% z
66.   uint32_t Crc;
    4 Q# f, \, r: u: ^* Z- H7 y, l9 r; Z. `
67. 
    7 M( a3 v# {& A0 m! ?) s! {
68.   Crc = 0;
    
69. 
    # y/ I# w. x2 v
70.   for(i=0; i<6; i++)
    " o9 V4 y9 k) Z4 R
71.   {
      P, j* Y) d. E. f/ w, t8 s
72.     Crc = Crc ^ (uint32_t)Mac<i>;
    
73. 
    
74. </i>   Crc = (Crc >> 4) ^ Crc32Tbl[Crc & 0x0F];  /* lower nibble */
    # N1 o* Y  ^3 U. r; d
75.     Crc = (Crc >> 4) ^ Crc32Tbl[Crc & 0x0F];  /* upper nibble */
    
76.   }
    
77. 
    
78.   return(Rev6Tbl[Crc & 0x3F]);
    
79. }
    ' s* ~4 S2 D! ]+ b4 T9 B+ k* Q
80. 
    3 s) O. {, m5 K5 v
81. int main(int argc, char **argv)
    
82. {
    " z2 m: A( S+ P3 u1 @
83.   static const uint8_t Test1[] = { 0x1F, 0x52, 0x41, 0x9C, 0xB6, 0xAF }; // 0x2C
    
84.   static const uint8_t Test2[] = { 0xA0, 0x0A, 0x98, 0x00, 0x00, 0x45 }; // 0x07
    # B$ \( U7 Y- D3 v9 y
85.   static const uint8_t Test3[] = { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x21 }; // 0x24
    
86. 
    
87.   printf("MacHash %02X\n", MacHash(Test1));
    
88.   printf("MacHash %02X\n", MacHash(Test2));
    
89.   printf("MacHash %02X\n", MacHash(Test3));
    
90. 
    
91.   printf("MacHashFast %02X\n", MacHashFast(Test1));
    
92.   printf("MacHashFast %02X\n", MacHashFast(Test2));
    
93.   printf("MacHashFast %02X\n", MacHashFast(Test3));
    , T$ h- X* n! ?% M" M1 E
94. 
    
95.   return(1);
    ) T! P5 V) n2 }! D3 q. Z1 o& o
96. }

复制代码

2 u1 y' \' Q) L- m8 \回到手册
  @* I+ u/ R0 B6 a/ L" x* u7 b

$ u- E" D9 q2 W: b9 \, Q+ r
上面的函数算出来一个数，假如是手册上的那个0x2c,二进制为101100B
换句看得懂的人话···就是：
算出来的数先看第6位
是1的话说明用到的是HASH表高位寄存器
6 n$ o/ n' G+ Q) T9 B3 d否则用到的是HASH表低位寄存器
( s- A! F+ Q, M2 A- j然后剩下的5位，转成十进制不是12嘛
6 n; ^0 ^  K% I7 d) j2 I8 I+ o如果你希望过滤这个MAC
5 [4 I" b4 W; j那么你就把对应的HASH表高/低位寄存器的对应位置1，否则置0
* o9 f: _9 |# O这里的0x2c就是要把
HASH表高位寄存器的第12位置1
( ^" Q3 }7 W1 U& w! s4 ]就可以过滤这条MAC了
$ K/ v2 ?  d. ~7 C然后把你希望的MAC地址都按照上面说的方法弄完

+ Q% y0 f5 U6 \回到这个函数稍微改一下
) `3 V, [: c9 n0 i- T7 }+ p

1. uint8_t ETH_MAC_Setting(ETH_HandleTypeDef *heth)
   : N* Z9 z- y8 o4 S4 z. }
2. {
   
3.     ETH_MACInitTypeDef macinit;
   
4.     /* Ethernet MAC default initialization **************************************/
   
5.     macinit.Watchdog = ETH_WATCHDOG_ENABLE;
   
6.     macinit.Jabber = ETH_JABBER_ENABLE;
   % ]4 N4 {$ b' h" f2 q
7.     macinit.InterFrameGap = ETH_INTERFRAMEGAP_96BIT;
   ) F; K5 W2 j* N( Y' ^  }, \1 X1 g
8.     macinit.CarrierSense = ETH_CARRIERSENCE_ENABLE;
   
9.     macinit.ReceiveOwn = ETH_RECEIVEOWN_ENABLE;
   
10.     macinit.LoopbackMode = ETH_LOOPBACKMODE_DISABLE;
    
11.     if (heth->Init.ChecksumMode == ETH_CHECKSUM_BY_HARDWARE)
    
12.     {
    
13.         macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_ENABLE;
    0 Z& J. \. e, w% r6 m9 ?
14.     }
    ' g2 s; i6 b. w8 G9 i1 e/ T' x
15.     else
    
16.     {
    
17.         macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_DISABLE;
    6 s. Y  Q/ ?2 J' w9 f) D
18.     }
    
19.     macinit.RetryTransmission = ETH_RETRYTRANSMISSION_ENABLE;          //使能重传
    , C) n6 G7 Q+ `/ x4 K
20.     macinit.AutomaticPadCRCStrip = ETH_AUTOMATICPADCRCSTRIP_ENABLE;          //使能自动去除
    $ p; M+ q% l$ {! F% O2 [
21.     macinit.BackOffLimit = ETH_BACKOFFLIMIT_10;
    
22.     macinit.DeferralCheck = ETH_DEFFERRALCHECK_DISABLE;
    
23.     macinit.ReceiveAll = ETH_RECEIVEAll_DISABLE; ///不接收所有包
    
24.     macinit.SourceAddrFilter = ETH_SOURCEADDRFILTER_NORMAL_ENABLE; //源地址过滤
    ( S  N1 ]0 G) j8 B# e6 t
25.     macinit.PassControlFrames = ETH_PASSCONTROLFRAMES_BLOCKALL;
    0 f5 r7 q- E2 D$ u  I# M9 H
26.     macinit.BroadcastFramesReception = ETH_BROADCASTFRAMESRECEPTION_DISABLE; //广播不接收
    
27.     macinit.DestinationAddrFilter = ETH_DESTINATIONADDRFILTER_NORMAL; //目的地址过滤
    % |! W& W' I5 r. T8 _: g
28.     macinit.PromiscuousMode = ETH_PROMISCUOUS_MODE_DISABLE; //混乱模式
    1 k- a! @; ^& z: }2 y. z
29.     macinit.MulticastFramesFilter = ETH_MULTICASTFRAMESFILTER_PERFECTHASHTABLE; //！！多播HASH完美过滤
    
30.     macinit.UnicastFramesFilter = ETH_UNICASTFRAMESFILTER_PERFECTHASHTABLE; //！！单播HASH完美过滤
    
31.     macinit.HashTableHigh = 0x0; //！！填你最后算完的Hash表高位
    , f8 u0 T; r8 q( w5 P+ X' D! ~
32.     macinit.HashTableLow = 0x0; //！！填你最后算完的Hash表低位
    6 D5 U$ p! ?1 j- K1 {; @( N
33.     macinit.PauseTime = 0x0;
    
34.     macinit.ZeroQuantaPause = ETH_ZEROQUANTAPAUSE_DISABLE;
    6 p; V5 R. X1 o) y& @3 N, K
35.     macinit.PauseLowThreshold = ETH_PAUSELOWTHRESHOLD_MINUS4;
    
36.     macinit.UnicastPauseFrameDetect = ETH_UNICASTPAUSEFRAMEDETECT_ENABLE;
    
37.     macinit.ReceiveFlowControl = ETH_RECEIVEFLOWCONTROL_DISABLE; //接收流控
    
38.     macinit.TransmitFlowControl = ETH_TRANSMITFLOWCONTROL_DISABLE; //发送流控
    
39.     macinit.VLANTagComparison = ETH_VLANTAGCOMPARISON_16BIT;
    
40.     macinit.VLANTagIdentifier = 0x0;
    3 o3 t+ R# W  d0 n6 V
41. 
    
42.     return HAL_ETH_ConfigMAC(heth, &macinit);
    
43. }

复制代码

. s; f' v) M7 K- E! P( o" F大概MAC层过滤就这些东西了
如果有条件弄MAC层过滤真的强烈建议开启，可以大幅减轻协议栈的处理负担，板卡不会因为处理大量无用的数据而白白浪费处理性能。

' _4 x1 |6 V& {8 O
% a; Q6 y; P0 m2 u! M0 Y$ ]. Y
$ x1 K, v3 u3 H( f- ^" Q% ?% j3 U
: o9 y: ~8 v/ j# @' Q) P