前景描述
我司的以太网实现是LAN8720搭配片上MAC层做的，协议栈用LWIP
9 Z1 }0 L  {) ~! `
这种做法应该还是蛮常见的，反正不是LAN8720就是DP83864，再不然就是硬件协议栈的W5500了

想想还是有MAC层过滤比较好，随手翻了翻它的手册，W5500好像是没得MAC层过滤的

! I: k4 i9 S4 Z9 ~! P  E假如数据速率比较高，数据量大，而且外面还有乱七八糟无关的数据往板卡送，我也不知道用这个片子到底好不好

LAN8720也不好改了，就继续用吧
+ O& G! Z6 X. V
好好在，发给板卡的数据的MAC还是有特征的，我只需要过滤发送方MAC地址的前3个字节，也就是特定的厂家那段

  a: ^; I- G) N& c/ l$ _/ O+ LMAC地址的科普知识这里就不过多描述了，我们直奔主题

怎么用STM32 F7的片上MAC做MAC层过滤
: L% E9 Q$ Z! p' l, g2 L7 [) \* ~1 q
写这个的目的，就是我搜了搜，没看见有人写这个MAC层过滤功能，具体代码怎么写才能用

. H4 O9 |: H$ [5 O知识科普-STM32的片上MAC
# ~- U  I+ G) g0 j" z8 E& \STM32 F7的MAC层过滤方式有三种(说人话的直白解释，中文手册其实也翻译的不好)
  R( O: V6 ^4 |9 u6 Y& a精确过滤(手册上叫单播目标/源地址过滤)
粗糙过滤(手册上叫Hash表过滤)
( I$ W0 f, Z* P2 @! b1 M4 L特殊过滤(广播，组播过滤等等特殊的过滤)
& K$ b# k- p% Z* t5 C我这里着重说第1种和第3种
- H2 g* d; A. H1 \4 W2 U) z  Y
STM32 F7可以存4个MAC地址
其中MAC地址0是自己的MAC，其他三个可以用来做过滤
$ }" u0 t' ]9 n
1 Q, P# q; |& R1 @6 t$ ^$ w, E网络数据包通过PHY进入STM32的MAC，MAC层是可以对目的地址/源地址检查并过滤掉没得用的数据的，默认的HAL库库函数HAL_ETH_Init中
有一个static的函数
static void ETH_MACDMAConfig(ETH_HandleTypeDef *heth, uint32_t err)
* q. `; Y7 t* x; A会帮你在初始化网络功能时初始化默认的MAC层功能:
7 X& [  {6 [/ e) V/ @& O关闭源地址过滤
不接收所有数据
接收广播帧
" k4 |! @0 f6 r4 s9 G7 l0 A) d3 F打开目的地地址过滤
单播数据精确过滤
9 u& l% u" C$ I9 `# d组播数据精确过滤
Hash表过滤关闭

其他的功能自行研究，我这里捡重要的说

1. static void ETH_MACDMAConfig(ETH_HandleTypeDef *heth, uint32_t err)
   ) h( \( G8 S& Y! S5 P, b
2. {
   9 L, Z: M1 n: D2 @3 g
3. ETH_MACInitTypeDef macinit;
   ; S$ g$ m' ?" ?9 M
4. ETH_DMAInitTypeDef dmainit;
   
5. uint32_t tmpreg = 0;
   , Y" S7 M  Y/ {, L
6. 
   
7. if (err != ETH_SUCCESS) /* Auto-negotiation failed */
   
8. {
   & |' |1 f, O5 L; `( v; q7 O1 o
9. /* Set Ethernet duplex mode to Full-duplex */
   
10. (heth->Init).DuplexMode = ETH_MODE_FULLDUPLEX;
    
11. 
    3 i' E3 w  ]' s3 P; v% w
12. /* Set Ethernet speed to 100M */
      W+ N# Y# }( \" w+ `( f" I' E
13. (heth->Init).Speed = ETH_SPEED_100M;
    " T) Q* B, {9 E* y* k+ w9 @
14. }
    
15. 
    5 a3 \7 f3 d. s/ q+ O  |" r
16. /* Ethernet MAC default initialization **************************************/
    
17. macinit.Watchdog = ETH_WATCHDOG_ENABLE;
    
18. macinit.Jabber = ETH_JABBER_ENABLE;
    ) I9 i- k7 G, H2 S/ N3 h$ i
19. macinit.InterFrameGap = ETH_INTERFRAMEGAP_96BIT;
    
20. macinit.CarrierSense = ETH_CARRIERSENCE_ENABLE;
    
21. macinit.ReceiveOwn = ETH_RECEIVEOWN_ENABLE;
    " z  W* l2 H, s4 F3 y
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
    # n5 ]6 b& o, m7 j* k
28. {
    ( |$ \3 D* `5 F& A' w, A6 U4 [1 q
29. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_DISABLE;
    & _( d+ m: `7 z8 }) N- u
30. }
    " r7 ^* j4 R2 {) O
31. //这一段是MAC层过滤的设置，下面是DMA的，那个用默认的就可以
    
32. macinit.RetryTransmission = ETH_RETRYTRANSMISSION_DISABLE;
    1 O  N. ~! X1 m  L) I
33. macinit.AutomaticPadCRCStrip = ETH_AUTOMATICPADCRCSTRIP_DISABLE;
    
34. macinit.BackOffLimit = ETH_BACKOFFLIMIT_10;
    
35. macinit.DeferralCheck = ETH_DEFFERRALCHECK_DISABLE;
    ' P  E2 |3 y6 A( [5 ?
36. macinit.ReceiveAll = ETH_RECEIVEAll_DISABLE;
    " T( J$ m4 a# B! J# a. P7 S
37. macinit.SourceAddrFilter = ETH_SOURCEADDRFILTER_DISABLE;
    - N) H: [5 p: R+ }0 d
38. macinit.PassControlFrames = ETH_PASSCONTROLFRAMES_BLOCKALL;
    / {/ i7 `  f8 K7 \
39. macinit.BroadcastFramesReception = ETH_BROADCASTFRAMESRECEPTION_ENABLE;
    6 z8 P! ~+ Z+ S# Z6 A( V3 q, P2 E+ I
40. macinit.DestinationAddrFilter = ETH_DESTINATIONADDRFILTER_NORMAL;
    % M8 Q9 R5 a1 b9 G0 j( L+ S: u
41. macinit.PromiscuousMode = ETH_PROMISCUOUS_MODE_DISABLE;
    
42. macinit.MulticastFramesFilter = ETH_MULTICASTFRAMESFILTER_PERFECT;
    
43. macinit.UnicastFramesFilter = ETH_UNICASTFRAMESFILTER_PERFECT;
    : T3 {" R4 \. {0 O7 R
44. macinit.HashTableHigh = 0x0;
    
45. macinit.HashTableLow = 0x0;
    
46. macinit.PauseTime = 0x0;
    
47. macinit.ZeroQuantaPause = ETH_ZEROQUANTAPAUSE_DISABLE;
    
48. macinit.PauseLowThreshold = ETH_PAUSELOWTHRESHOLD_MINUS4;
    + ~: y, ]6 T- x( p
49. macinit.UnicastPauseFrameDetect = ETH_UNICASTPAUSEFRAMEDETECT_DISABLE;
    ) q0 D' D2 r& J" `: M. ~
50. macinit.ReceiveFlowControl = ETH_RECEIVEFLOWCONTROL_DISABLE;
    " r5 L9 e  I" a$ Y8 Q
51. macinit.TransmitFlowControl = ETH_TRANSMITFLOWCONTROL_DISABLE;
    : E. m& H. D  r+ e7 e& [) w; s# [
52. macinit.VLANTagComparison = ETH_VLANTAGCOMPARISON_16BIT;
    6 V2 O1 k( ~9 s1 {# Z  k
53. macinit.VLANTagIdentifier = 0x0;
    3 J; U4 L! [4 h- D
54. 
    ) a" a" ~1 Q9 Q( e* N; E' |
55. /*------------------------ ETHERNET MACCR Configuration --------------------*/
    
56. /* Get the ETHERNET MACCR value */
    ( H! @8 ^( a- ^: q9 j: f/ C' b
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 */
    1 c  I( p0 n& K. T; L% ]& t
61. /* Set the JD: bit according to ETH Jabber value */
    2 M& X, ^; V: y  Q
62. /* Set the IFG bit according to ETH InterFrameGap value */
    
63. /* Set the DCRS bit according to ETH CarrierSense value */
    3 y% p8 ^! V; D
64. /* Set the FES bit according to ETH Speed value */
    7 P# G8 K7 `* ]- ?
65. /* Set the DO bit according to ETH ReceiveOwn value */
    
66. /* Set the LM bit according to ETH LoopbackMode value */
    / A3 T7 Q& m- X3 J
67. /* Set the DM bit according to ETH Mode value */
    ; f7 f& d7 H: s7 Z/ L
68. /* Set the IPCO bit according to ETH ChecksumOffload value */
    
69. /* Set the DR bit according to ETH RetryTransmission value */
    
70. /* Set the ACS bit according to ETH AutomaticPadCRCStrip value */
    5 ~0 i) \. n6 X( Y+ ]+ z7 ^( O; e
71. /* Set the BL bit according to ETH BackOffLimit value */
    5 V" [! X- t3 J3 t
72. /* Set the DC bit according to ETH DeferralCheck value */
    
73. tmpreg |= (uint32_t)(macinit.Watchdog |
    
74. macinit.Jabber |
    
75. macinit.InterFrameGap |
      s% H2 v' R1 z) C& e( z) l" [
76. macinit.CarrierSense |
    
77. (heth->Init).Speed |
    
78. macinit.ReceiveOwn |
    , ^4 o& w: H% e# e
79. macinit.LoopbackMode |
    + l8 i2 v  n) C7 B
80. (heth->Init).DuplexMode |
    % i/ `' x& f" d
81. macinit.ChecksumOffload |
    " S5 w. l" `( H4 v7 h8 ]
82. macinit.RetryTransmission |
    7 g5 d- l: c$ q- @4 j
83. macinit.AutomaticPadCRCStrip |
    ! d+ a2 T6 N  q! u/ v8 U8 t
84. macinit.BackOffLimit |
      ]5 J" p$ y7 _
85. macinit.DeferralCheck);
    7 p7 u) [# W, ?3 `
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;
    
93. HAL_Delay(ETH_REG_WRITE_DELAY);
    
94. (heth->Instance)->MACCR = tmpreg;
    
95. 
    4 _/ y& b( |+ H5 `- p
96. /*----------------------- ETHERNET MACFFR Configuration --------------------*/
    
97. /* Set the RA bit according to ETH ReceiveAll value */
    
98. /* Set the SAF and SAIF bits according to ETH SourceAddrFilter value */
    1 i/ g; d8 x6 U
99. /* Set the PCF bit according to ETH PassControlFrames value */
    
100. /* Set the DBF bit according to ETH BroadcastFramesReception value */
     3 H* z9 l8 D( U0 z
101. /* Set the DAIF bit according to ETH DestinationAddrFilter value */
       |: }. q. G" ]) V/ e( F5 P
102. /* Set the PR bit according to ETH PromiscuousMode value */
     
103. /* Set the PM, HMC and HPF bits according to ETH MulticastFramesFilter value */
     % a: c( p4 a# p) y% U
104. /* Set the HUC and HPF bits according to ETH UnicastFramesFilter value */
     9 S% p8 n7 ?: S
105. /* Write to ETHERNET MACFFR */
     
106. (heth->Instance)->MACFFR = (uint32_t)(macinit.ReceiveAll |
     3 p' S$ ?' m9 A0 x% u) q5 y
107. macinit.SourceAddrFilter |
     + K3 C8 M8 s9 M/ E  d
108. macinit.PassControlFrames |
     / a1 x8 c& D) u2 z# m+ E- [  G
109. macinit.BroadcastFramesReception |
     1 I) I  Q. [' ^3 z: e
110. macinit.DestinationAddrFilter |
     
111. macinit.PromiscuousMode |
     0 }4 o* Q" @5 X+ X+ {6 |6 d) ]! s
112. macinit.MulticastFramesFilter |
     
113. macinit.UnicastFramesFilter);
     
114. 
     2 ]- e) x: _% z
115. /* Wait until the write operation will be taken into account:
     
116. at least four TX_CLK/RX_CLK clock cycles */
     
117. tmpreg = (heth->Instance)->MACFFR;
     
118. HAL_Delay(ETH_REG_WRITE_DELAY);
     
119. (heth->Instance)->MACFFR = tmpreg;
     4 s1 C4 D4 ~4 Q$ Q! a6 \
120. 
     % m' r8 Z/ W; a. c( w$ b5 t4 b! }& @
121. /*--------------- ETHERNET MACHTHR and MACHTLR Configuration --------------*/
     6 m- j; I+ o) ^: M& V0 z
122. /* Write to ETHERNET MACHTHR */
     
123. (heth->Instance)->MACHTHR = (uint32_t)macinit.HashTableHigh;
     
124. 
     ) K- @. Z% {+ D) W
125. /* Write to ETHERNET MACHTLR */
     6 A- d, L8 x+ l" Z3 e# j7 J: L6 p
126. (heth->Instance)->MACHTLR = (uint32_t)macinit.HashTableLow;
     ( Y+ M+ l9 D' @5 o- V; A, _
127. /*----------------------- ETHERNET MACFCR Configuration -------------------*/
     ) J$ e* ]; }; |( U
128. 
       v; s( Y/ |( J1 z
129. /* Get the ETHERNET MACFCR value */
     
130. tmpreg = (heth->Instance)->MACFCR;
     , Y: i& B3 e9 ?- c, |
131. /* Clear xx bits */
     
132. tmpreg &= ETH_MACFCR_CLEAR_MASK;
     + w' ]+ v& R$ _8 f( }) {4 K
133. 
     3 V6 |9 }% ^0 S# R- X. u
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 */
     ! v4 k1 i1 x0 n+ `
137. /* Set the UP bit according to ETH UnicastPauseFrameDetect value */
     ; }8 J8 X9 {! N8 q9 \7 z7 `
138. /* Set the RFE bit according to ETH ReceiveFlowControl value */
     
139. /* Set the TFE bit according to ETH TransmitFlowControl value */
     
140. tmpreg |= (uint32_t)((macinit.PauseTime Instance)->MACFCR = (uint32_t)tmpreg;
     
141. 
     
142. /* Wait until the write operation will be taken into account:
     $ H9 g7 |, }% V) a& w9 {( z: D% N
143. at least four TX_CLK/RX_CLK clock cycles */
     
144. tmpreg = (heth->Instance)->MACFCR;
     
145. HAL_Delay(ETH_REG_WRITE_DELAY);
     ' d7 K" u9 s# _9 C5 M9 Y3 L7 `
146. (heth->Instance)->MACFCR = tmpreg;
     
147. 
     ( |9 I) W9 L0 a, o7 c& j5 m
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 |
     " F  u9 d' m3 C% b
152. macinit.VLANTagIdentifier);
     
153. 
     
154. /* Wait until the write operation will be taken into account:
     5 l! V) K, c2 Y' {5 ^8 L/ d
155.    at least four TX_CLK/RX_CLK clock cycles */
     
156. tmpreg = (heth->Instance)->MACVLANTR;
     
157. HAL_Delay(ETH_REG_WRITE_DELAY);
     9 Z* e# _; s+ J
158. (heth->Instance)->MACVLANTR = tmpreg;
     / ?( v  D+ }3 L* A! `
159. 
     
160. /* Ethernet DMA default initialization ************************************/
     
161. dmainit.DropTCPIPChecksumErrorFrame = ETH_DROPTCPIPCHECKSUMERRORFRAME_ENABLE;
     
162. dmainit.ReceiveStoreForward = ETH_RECEIVESTOREFORWARD_ENABLE;
     4 `0 w8 I4 W  e& b5 {( ^2 N% T2 t
163. dmainit.FlushReceivedFrame = ETH_FLUSHRECEIVEDFRAME_ENABLE;
     
164. dmainit.TransmitStoreForward = ETH_TRANSMITSTOREFORWARD_ENABLE;
     
165. dmainit.TransmitThresholdControl = ETH_TRANSMITTHRESHOLDCONTROL_64BYTES;
     7 o5 v" B! R0 u
166. dmainit.ForwardErrorFrames = ETH_FORWARDERRORFRAMES_DISABLE;
     & I5 G  q- v$ r  M  U# C6 \, N
167. dmainit.ForwardUndersizedGoodFrames = ETH_FORWARDUNDERSIZEDGOODFRAMES_DISABLE;
     4 [7 g/ _" k2 |9 A
168. dmainit.ReceiveThresholdControl = ETH_RECEIVEDTHRESHOLDCONTROL_64BYTES;
     
169. dmainit.SecondFrameOperate = ETH_SECONDFRAMEOPERARTE_ENABLE;
     
170. dmainit.AddressAlignedBeats = ETH_ADDRESSALIGNEDBEATS_ENABLE;
     * w6 @% @6 i' u1 e) c
171. dmainit.FixedBurst = ETH_FIXEDBURST_ENABLE;
     
172. dmainit.RxDMABurstLength = ETH_RXDMABURSTLENGTH_32BEAT;
     
173. dmainit.TxDMABurstLength = ETH_TXDMABURSTLENGTH_32BEAT;
     
174. dmainit.EnhancedDescriptorFormat = ETH_DMAENHANCEDDESCRIPTOR_ENABLE;
     
175. dmainit.DescriptorSkipLength = 0x0;
     / S, ~3 R# t2 S# k/ a" ?' v
176. dmainit.DMAArbitration = ETH_DMAARBITRATION_ROUNDROBIN_RXTX_1_1;
     
177. 
     & {. _6 c' W& \( m
178. /* Get the ETHERNET DMAOMR value */
     
179. tmpreg = (heth->Instance)->DMAOMR;
     
180. /* Clear xx bits */
     " C0 Y$ f  c  Y" P; Q& @2 e  c# M
181. tmpreg &= ETH_DMAOMR_CLEAR_MASK;
     
182. 
     " v9 \; l6 L1 h
183. /* Set the DT bit according to ETH DropTCPIPChecksumErrorFrame value */
     8 l5 |5 v, u5 E$ B" U5 X
184. /* Set the RSF bit according to ETH ReceiveStoreForward value */
     2 c1 R. {5 [  k( I- S7 C
185. /* Set the DFF bit according to ETH FlushReceivedFrame value */
     8 x* g! f) {% ^. ?9 s
186. /* Set the TSF bit according to ETH TransmitStoreForward value */
     
187. /* Set the TTC bit according to ETH TransmitThresholdControl value */
     
188. /* Set the FEF bit according to ETH ForwardErrorFrames value */
     
189. /* Set the FUF bit according to ETH ForwardUndersizedGoodFrames value */
     0 D! s- C. P3 S+ v. {8 k* q
190. /* Set the RTC bit according to ETH ReceiveThresholdControl value */
     / k- d+ R5 Q1 x* f0 m/ I5 U) ^: ~
191. /* Set the OSF bit according to ETH SecondFrameOperate value */
     4 O4 O( Q) M- M* c
192. tmpreg |= (uint32_t)(dmainit.DropTCPIPChecksumErrorFrame |
     8 x$ y( p+ ]) k% k
193.                      dmainit.ReceiveStoreForward |
     # S) L$ ?, Y# r1 \" q- r* O. A7 S
194.                      dmainit.FlushReceivedFrame |
     6 ?& o" J, B3 Y& M- D
195.                      dmainit.TransmitStoreForward |
     
196.                      dmainit.TransmitThresholdControl |
     . D9 T, v% A: f, w
197.                      dmainit.ForwardErrorFrames |
     
198.                      dmainit.ForwardUndersizedGoodFrames |
     
199.                      dmainit.ReceiveThresholdControl |
     + Q! I/ U5 @! I0 P* e! A3 Y( j
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);
     0 t# O6 o9 J% N# `6 u9 x8 i: C
209. (heth->Instance)->DMAOMR = tmpreg;
     8 T/ L) E, u; P" u/ S) a2 J% v( N
210. 
     / i# N2 |) q9 Z
211. /*----------------------- ETHERNET DMABMR Configuration ------------------*/
     2 _: a1 D: _. T8 F# U
212. /* Set the AAL bit according to ETH AddressAlignedBeats value */
     
213. /* Set the FB bit according to ETH FixedBurst value */
     - Y3 B/ l' S4 i! K; Y
214. /* Set the RPBL and 4*PBL bits according to ETH RxDMABurstLength value */
     
215. /* Set the PBL and 4*PBL bits according to ETH TxDMABurstLength value */
     " h, K5 {9 r* D
216. /* Set the Enhanced DMA descriptors bit according to ETH EnhancedDescriptorFormat value*/
     3 G5 J' l+ i- Q. Z1 d) t: U9 _
217. /* Set the DSL bit according to ETH DesciptorSkipLength value */
     7 B; F- h& Z( }$ {8 S3 ~, t
218. /* Set the PR and DA bits according to ETH DMAArbitration value */
     & O5 ~4 b% B5 C+ l& j
219. (heth->Instance)->DMABMR = (uint32_t)(dmainit.AddressAlignedBeats |
     
220.                                       dmainit.FixedBurst |
     
221.                                       dmainit.RxDMABurstLength |    /* !! if 4xPBL is selected for Tx or Rx it is applied for the other */
     
222.                                       dmainit.TxDMABurstLength |
     6 O( `9 K& k" F0 x
223.                                       dmainit.EnhancedDescriptorFormat |
     
224.                                       (dmainit.DescriptorSkipLength Instance)->DMABMR;
     $ z/ I) u. X0 p7 a% j( P& j& g
225. HAL_Delay(ETH_REG_WRITE_DELAY);
     
226. (heth->Instance)->DMABMR = tmpreg;
     2 O5 T% l5 L$ P3 p
227. 
     
228. if((heth->Init).RxMode == ETH_RXINTERRUPT_MODE)
     , K& n0 f) Q- U  p# o; L
229. {
     # W( w- |% s' S
230.    /* Enable the Ethernet Rx Interrupt */
     
231.    __HAL_ETH_DMA_ENABLE_IT((heth), ETH_DMA_IT_NIS | ETH_DMA_IT_R);
     
232. }
     $ q0 N# [. s9 ^2 J3 S# L) q2 K
233. 
     . G$ T4 x1 z2 a/ x  }/ H; b1 N
234. /* Initialize MAC address in ethernet MAC */
     6 ]% W) h- h( F; {7 |; M
235. ETH_MACAddressConfig(heth, ETH_MAC_ADDRESS0, heth->Init.MACAddr);
     
236. }

复制代码

这里我就要稍微吐槽一下HAL库了
MAC层过滤的设置没有预留接口出来，有设置MAC地址的函数

static void ETH_MACAddressConfig(ETH_HandleTypeDef *heth, uint32_t MacAddr, uint8_t *Addr)

就不多做一个设置MAC层过滤的函数嘛，连后面用到的宏定义都有~~
8 v* V- Q# Y7 h- ^% L9 P
木有办法，自己编一个初始化MAC层过滤的函数吧
: _; B7 K: _7 J* d
/ V0 w, N9 S' y+ b其实也就是把上面这个ETH_MACDMAConfig函数分离成两个单独的设置函数，再编一个设置MAC层过滤的函数
* c3 Y0 Z) ]  j' w+ v# L
开启MAC层过滤的初始化代码
! w& W" y( [. b9 A

1. uint8_t ETH_MAC_Setting(ETH_HandleTypeDef *heth)
   
2. {
   / w: ~1 m9 m1 n8 B# U' y& G
3. ETH_MACInitTypeDef macinit;
   
4. /* Ethernet MAC default initialization **************************************/
   . L% \9 Q5 S9 R! ]. Q: w
5. macinit.Watchdog = ETH_WATCHDOG_ENABLE;
   
6. macinit.Jabber = ETH_JABBER_ENABLE;
   
7. macinit.InterFrameGap = ETH_INTERFRAMEGAP_96BIT;
   
8. macinit.CarrierSense = ETH_CARRIERSENCE_ENABLE;
   
9. macinit.ReceiveOwn = ETH_RECEIVEOWN_ENABLE;
   % d* ~' w, A+ @* ?
10. macinit.LoopbackMode = ETH_LOOPBACKMODE_DISABLE;
    2 }& o( s$ J- P% ~' F8 I8 ]
11. if (heth->Init.ChecksumMode == ETH_CHECKSUM_BY_HARDWARE)
    : z1 A8 G+ U7 o3 r( Y$ M# G
12. {
    % d4 T% g: l0 {" E6 n) A$ F) P
13. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_ENABLE;
    $ u6 S4 S8 N& {8 l
14. }
    
15. else
    
16. {
    
17. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_DISABLE;
    ' g4 |& d* S7 P; V
18. }
    1 d& c% A2 H4 L' }& J
19. macinit.RetryTransmission = ETH_RETRYTRANSMISSION_ENABLE;          //使能重传
    % f+ p: k9 T6 Q/ ?- E; O
20. macinit.AutomaticPadCRCStrip = ETH_AUTOMATICPADCRCSTRIP_ENABLE;          //使能自动去除
    
21. macinit.BackOffLimit = ETH_BACKOFFLIMIT_10;
    # i8 i8 q2 u$ F  [; n
22. macinit.DeferralCheck = ETH_DEFFERRALCHECK_DISABLE;
    
23. macinit.ReceiveAll = ETH_RECEIVEAll_DISABLE; ///不接收所有包
    
24. macinit.SourceAddrFilter = ETH_SOURCEADDRFILTER_NORMAL_ENABLE; //源地址过滤
    
25. macinit.PassControlFrames = ETH_PASSCONTROLFRAMES_BLOCKALL;
    
26. macinit.BroadcastFramesReception = ETH_BROADCASTFRAMESRECEPTION_DISABLE; //广播不接收
    
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; //单播过滤
    * s9 D- o/ C' Y1 p# j
31. macinit.HashTableHigh = 0x0; //Hash表高位
    
32. macinit.HashTableLow = 0x0; //Hash表低位
    
33. macinit.PauseTime = 0x0;
    $ O+ V- P3 ]6 ~- G9 f+ l1 w
34. macinit.ZeroQuantaPause = ETH_ZEROQUANTAPAUSE_DISABLE;
    0 e4 l+ P, |, e$ E2 O
35. macinit.PauseLowThreshold = ETH_PAUSELOWTHRESHOLD_MINUS4;
    
36. macinit.UnicastPauseFrameDetect = ETH_UNICASTPAUSEFRAMEDETECT_ENABLE;
    
37. macinit.ReceiveFlowControl = ETH_RECEIVEFLOWCONTROL_DISABLE; //接收流控
    
38. macinit.TransmitFlowControl = ETH_TRANSMITFLOWCONTROL_DISABLE; //发送流控
    ; v% j. r4 ~8 u/ O  C$ Z
39. macinit.VLANTagComparison = ETH_VLANTAGCOMPARISON_16BIT;
    
40. macinit.VLANTagIdentifier = 0x0;
    5 Q" H$ ?0 t4 ]' v. E. V
41. 
    
42. return HAL_ETH_ConfigMAC(heth, &macinit);
    : i" s) |7 i+ Y: Q+ X6 R6 o1 T
43. }

复制代码

默认的MAC层 DMA初始化函数
+ P4 R* f% i- @7 R

1. uint8_t ETH_DMA_Setting(ETH_HandleTypeDef *heth)
   
2. {
   
3. ETH_DMAInitTypeDef dmainit;
     w. F+ ]; F3 L
4. /* Ethernet DMA default initialization ************************************/
   2 r1 |9 t. Z! d" Y- X
5. dmainit.DropTCPIPChecksumErrorFrame = ETH_DROPTCPIPCHECKSUMERRORFRAME_ENABLE;
   3 h4 b# L2 J4 v  X' V
6. dmainit.ReceiveStoreForward = ETH_RECEIVESTOREFORWARD_ENABLE;
   ! K: g" \$ c8 W3 o- s& k9 d8 H" O0 E
7. dmainit.FlushReceivedFrame = ETH_FLUSHRECEIVEDFRAME_ENABLE;
   , f4 p; E# f6 v% w$ O
8. dmainit.TransmitStoreForward = ETH_TRANSMITSTOREFORWARD_ENABLE;
   
9. dmainit.TransmitThresholdControl = ETH_TRANSMITTHRESHOLDCONTROL_64BYTES;
   
10. dmainit.ForwardErrorFrames = ETH_FORWARDERRORFRAMES_DISABLE;
    
11. dmainit.ForwardUndersizedGoodFrames = ETH_FORWARDUNDERSIZEDGOODFRAMES_DISABLE;
    ! v+ |& q" G, o" A/ {* M
12. dmainit.ReceiveThresholdControl = ETH_RECEIVEDTHRESHOLDCONTROL_64BYTES;
    
13. dmainit.SecondFrameOperate = ETH_SECONDFRAMEOPERARTE_ENABLE;
    : j; y; E$ S) K# q+ G9 h
14. dmainit.AddressAlignedBeats = ETH_ADDRESSALIGNEDBEATS_ENABLE;
    
15. dmainit.FixedBurst = ETH_FIXEDBURST_ENABLE;
    
16. dmainit.RxDMABurstLength = ETH_RXDMABURSTLENGTH_32BEAT;
    
17. dmainit.TxDMABurstLength = ETH_TXDMABURSTLENGTH_32BEAT;
    " _  V, N9 h  R6 h( L; f
18. dmainit.EnhancedDescriptorFormat = ETH_DMAENHANCEDDESCRIPTOR_ENABLE;
    0 x3 F4 p; d2 F5 x
19. dmainit.DescriptorSkipLength = 0x0;
    
20. dmainit.DMAArbitration = ETH_DMAARBITRATION_ROUNDROBIN_RXTX_1_1;
    
21. uint8_t res =  HAL_ETH_ConfigDMA(heth, &dmainit);
    5 ]  M5 n) U$ `  b. b$ `: P
22. if ((heth->Init).RxMode == ETH_RXINTERRUPT_MODE)
    
23. {
    
24. /* Enable the Ethernet Rx Interrupt */
    
25. __HAL_ETH_DMA_ENABLE_IT((heth), ETH_DMA_IT_NIS | ETH_DMA_IT_R);
    
26. }
    ! ]6 P( D& d* A% F1 U, o! w* D
27. return res;
    , Y' l$ H  X2 M, T9 x: e" X
28. }

复制代码

3 |. M. J5 v- p1 l用来设置MAC地址的函数(其实就是把库函数的static函数取出来直接用了)

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

复制代码

7 z0 l* G- `" ?& i然后到最最重要的MAC层过滤设置
5 j0 y$ D5 ]0 r# n: Q# i以MAC1为例
7 Z4 o* m3 H/ Q- y; y4 d9 a1 R
* p5 k% @( p' H. ~6 {4 N8 D* _( z, N

- H4 [( g0 X4 F, N! n" p( d/ z, ^

' U: U3 F! {& ?9 b- g% T3 D& u
; M3 g1 t! u/ D: J注意看红框的描述
功能很好用，可以过滤源地址/目的地址，还可以做掩码功能
; T' R5 j( s6 F4 g" ^: ?" U. X设置MAC层过滤的代码

1. static void ETH_MAC_Filter_Setting(ETH_HandleTypeDef *heth,ST_ETH_PAR * para)
   : i* y+ ^* D' ]. z: E- {
2. {
   ( p0 `; l* E) M" j8 o
3.     //设置本机MAC地址
   
4.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS0, heth->Init.MACAddr);
   
5.     //设置UDP-A的对方MAC地址
     Y# w' Y. V0 l9 n7 d! A8 c
6.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS1,para->UDP_A_MAC);
   ) s1 r7 ~( i7 |, I# V
7.     (heth->Instance)->MACA1HR|=0xC0000000;//需要完全匹配UDP-A的对方MAC才接收
   ) u% K" D2 F* G  G# @3 K9 G
8.     //设置UDP-B的对方MAC地址
   " `2 P( L# W+ I6 M2 L
9.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS2,para->UDP_B_MAC);
   ( F- |9 B) S# B1 \8 g$ I% t6 y1 Q# i
10.     (heth->Instance)->MACA2HR|=0xC0000000;//需要完全匹配UDP-A的对方MAC才接收
    
11. }

复制代码

我这里是希望为我的两个UDP精确过滤接收到的源地址
8 E3 ?2 ]$ q4 q; c所以AE位设置为1，SA设置为1，MBC全部为0(MAC地址全部检查)
0 q! x) w4 N/ W+ _* q) Q- _
假如我希望过滤MAC中特定的厂家字段
. a0 J0 L. G! H3 H  V例如某个MAC地址
01-02-03-04-05-06
其中01-02-03就是厂家字段

那么代码要这样修改（MBC的第29位，28位，27位置1）
' I5 e# {2 B1 b  T1 w0 u* h这样MAC层就不会检查MAC地址里后3个字节(04-05-06)
但是会检查前3个字节，也就是厂家字段
8 z, w% T" p) b+ g2 j1 F这里需要注意MAC地址的字节序
" x  |4 m# c/ l0 t

1. static void ETH_MAC_Filter_Setting(ETH_HandleTypeDef *heth,ST_ETH_PAR * para)
   
2. {
   : u/ G  Z4 Q0 _  a: A; L0 O
3.     //设置本机MAC地址
   
4.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS0, heth->Init.MACAddr);
   / T" D5 g1 @6 W5 e0 N
5.     //设置UDP-A的对方MAC地址
   $ {3 V9 Q! O0 S# W, G& n( G
6.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS1,para->UDP_A_MAC);
   5 |# z3 c% h8 S! `! L" ?) m
7.     (heth->Instance)->MACA1HR|=0xF8000000;//需要匹配厂家字段
   4 }2 o4 U7 H% A  F0 t
8.     //设置UDP-B的对方MAC地址
   
9.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS2,para->UDP_B_MAC);
     t8 J6 J' M  k8 m! d8 q( y
10.     (heth->Instance)->MACA2HR|=0xF8000000;//需要匹配厂家字段
    
11. }

复制代码

  b# v* n3 q1 Q& }" c- @& |  @然后这些函数的调用顺序按:
: X5 i6 c% Q4 K# f& P1. HAL_ETH_Init
2. ETH_MAC_Setting
% P& ^' J% t0 @8 [& H5 H: [1 P3. ETH_DMA_Setting
4. ETH_MAC_Filter_Setting

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

HASH函数
函数
; s$ |* Y2 S9 ~% n7 |

1. / STM32 MACHASH - Copyright (C) 2014-2018 Clive Turvey (<a href="mailto:sourcer32@gmail.com">sourcer32@gmail.com</a>)
   
2. //  All Rights Reserved
   % v4 O% Z7 y' p' n  y3 T
3. 
   
4. #include <windows.h>
   
5. 
   0 V' w; m! i3 @5 X; c
6. #include <stdio.h>
   
7. #include <stdlib.h>
   : C4 a) u5 w# u
8. 
   
9. typedef unsigned char uint8_t;
   
10. typedef unsigned long uint32_t;
    2 @1 F8 o9 ?' ]4 u/ e; ?# d* p
11. 
    ) w1 {/ [- x7 v+ Z5 B3 r
12. uint32_t Rev32(uint32_t x)
    2 p8 Z. _9 u, B
13. {
    2 p2 [" }( x( S' ]7 D
14.   uint32_t y;
    4 t: p: k' N5 ?1 l- y7 J
15.   int i;
    
16. 
    
17.   y = 0;
    : p' e( p; N8 a! c7 R$ m) A) u
18. 
    
19.   for(i=0; i<32; i++)
    % d; w; u# \/ o  B
20.     if (x & (1 << i))
    % Q$ Q: I; x2 Y0 J9 \( N- s# f
21.       y |= 1 << (31 - i);
    
22. 
    5 x/ M3 I9 C$ V& b% h5 j
23.   return(y);
    . }% O4 \# j1 _2 N- M
24. }
    
25. 
    7 \& h3 {: k! Q  B
26. uint32_t MacHash(const uint8_t *Mac) // <a href="mailto:sourcer32@gmail.com">sourcer32@gmail.com</a>
    
27. {
    0 }  Y0 s" B; ?# A3 ~. Y
28.   int i, j;
    / U; T0 M( c! l4 S+ H- q3 g
29.   uint32_t Crc;
    
30. 
    : F- g9 H3 X0 n
31.   Crc = 0xFFFFFFFF;
    ! ?' v! g8 W) ?1 J( O* C6 }! ]/ G
32. 
    
33.   for(j=0; j<6; j++)
    8 M" D6 b( ?5 t$ [4 t2 c
34.   {
    ; ^9 d) w" W/ C* K
35.     Crc = Crc ^ (uint32_t)Mac[j];
    
36. 
    
37.     for(i=0; i<8; i++)
    ( y" G4 B7 C9 T$ c
38.       if (Crc & 1)
    
39.         Crc = (Crc >> 1) ^ 0xEDB88320; // Reversed 0x04C11DB7
    
40.       else
    / n' ?1 U! L7 |" q/ v* F) B3 L& j
41.         Crc = (Crc >> 1);
    
42.   }
      D& v4 j& [$ m. }; I
43. 
    
44.   return(Rev32(~Crc) >> 26); // Get High order 6-bit in reversed/inverted CRC
    $ O5 s4 u7 G8 y6 q5 K
45. }
    
46. 
    
47. uint32_t MacHashFast(const uint8_t *Mac) // <a href="mailto:sourcer32@gmail.com">sourcer32@gmail.com</a>
    5 q1 a, |0 ]: Q8 O, k
48. {
    
49.   static const uint32_t Rev6Tbl[] = {
    & o3 }- o6 c* P
50.     0x00,0x20,0x10,0x30,0x08,0x28,0x18,0x38,
    
51.     0x04,0x24,0x14,0x34,0x0C,0x2C,0x1C,0x3C,
    $ i" r+ a1 w' Y8 O! s! A* s# Z
52.     0x02,0x22,0x12,0x32,0x0A,0x2A,0x1A,0x3A,
    8 G0 V9 g. ?" A; U. r# K
53.     0x06,0x26,0x16,0x36,0x0E,0x2E,0x1E,0x3E,
    : n/ y1 s$ f- v
54.     0x01,0x21,0x11,0x31,0x09,0x29,0x19,0x39,
    ; T  k3 G  J: [+ W
55.     0x05,0x25,0x15,0x35,0x0D,0x2D,0x1D,0x3D,
    
56.     0x03,0x23,0x13,0x33,0x0B,0x2B,0x1B,0x3B,
    
57.     0x07,0x27,0x17,0x37,0x0F,0x2F,0x1F,0x3F };
    0 t: V2 f* ~2 Y0 T. W) Y
58. 
    
59.   static const uint32_t Crc32Tbl[] = {
    
60.     0x4DBDF21C, 0x500AE278, 0x76D3D2D4, 0x6B64C2B0,
    " _" u9 q5 T% \" h4 C
61.     0x3B61B38C, 0x26D6A3E8, 0x000F9344, 0x1DB88320,
    
62.     0xA005713C, 0xBDB26158, 0x9B6B51F4, 0x86DC4190,
    
63.     0xD6D930AC, 0xCB6E20C8, 0xEDB71064, 0xF0000000 };
    5 Z/ p+ z5 B' G  p. |
64. 
    3 ^/ ~. i: d- c4 T% e7 X) D
65.   int i;
    3 d3 L* t& e- C7 W: J
66.   uint32_t Crc;
    
67. 
    $ t5 o6 I* {( ^9 R. T' \
68.   Crc = 0;
    
69. 
    + B! o. u# W+ ~" p- q5 I
70.   for(i=0; i<6; i++)
    ' f2 Q& M" ~7 N; }
71.   {
    
72.     Crc = Crc ^ (uint32_t)Mac<i>;
    
73. 
    $ w- Y1 [! o% E  T4 }
74. </i>   Crc = (Crc >> 4) ^ Crc32Tbl[Crc & 0x0F];  /* lower nibble */
    ( o* D6 g+ r- l
75.     Crc = (Crc >> 4) ^ Crc32Tbl[Crc & 0x0F];  /* upper nibble */
    
76.   }
    # G3 ~9 J  d2 H/ Y: U, ]
77. 
    
78.   return(Rev6Tbl[Crc & 0x3F]);
    
79. }
    + ]* i4 o7 Y- `( j) g/ Z) b. u
80. 
    
81. int main(int argc, char **argv)
    & L: R2 v( {/ y
82. {
    $ z- _9 ]: E6 |4 P
83.   static const uint8_t Test1[] = { 0x1F, 0x52, 0x41, 0x9C, 0xB6, 0xAF }; // 0x2C
    , q, y; s9 [- E+ }7 J
84.   static const uint8_t Test2[] = { 0xA0, 0x0A, 0x98, 0x00, 0x00, 0x45 }; // 0x07
    2 u2 V, d! |9 B0 D& `
85.   static const uint8_t Test3[] = { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x21 }; // 0x24
    
86. 
    
87.   printf("MacHash %02X\n", MacHash(Test1));
    7 _: _; I2 o! P3 U6 w
88.   printf("MacHash %02X\n", MacHash(Test2));
    # H& i4 y4 z, s" U
89.   printf("MacHash %02X\n", MacHash(Test3));
      T' c, Y% ]* @7 V
90. 
    : W: ~* d' E4 n; D9 J& D7 h
91.   printf("MacHashFast %02X\n", MacHashFast(Test1));
    8 p& v) ^) G5 h: ~+ c5 A" f
92.   printf("MacHashFast %02X\n", MacHashFast(Test2));
    ! L8 P* X% {& I7 ?' p8 S
93.   printf("MacHashFast %02X\n", MacHashFast(Test3));
    
94. 
    $ f: Q. b& h6 b# F) ~
95.   return(1);
    - {$ ]* d5 P1 V7 i. X* @  {
96. }

复制代码

1 r; n; W4 c6 u+ h, l
回到手册
/ Q6 A1 ~; @) ]; ?
; |0 X" u7 l# \5 p) ^* S+ S: v

5 i) k9 M5 h$ i: i
9 U* `. J/ `3 E! ]% o+ \2 u1 f
上面的函数算出来一个数，假如是手册上的那个0x2c,二进制为101100B
* P. E, v) e% h- S/ B) H8 F! y4 Z换句看得懂的人话···就是：
算出来的数先看第6位
5 K& R5 y& y% ]是1的话说明用到的是HASH表高位寄存器
0 w$ R# W3 M6 y否则用到的是HASH表低位寄存器
然后剩下的5位，转成十进制不是12嘛
* |$ {- X  o# r如果你希望过滤这个MAC
那么你就把对应的HASH表高/低位寄存器的对应位置1，否则置0
, Z' `5 C, g) l7 Q4 d这里的0x2c就是要把
HASH表高位寄存器的第12位置1
7 w  x+ w2 O, e就可以过滤这条MAC了
然后把你希望的MAC地址都按照上面说的方法弄完
+ t* I( U$ c( B" R
. [, h) t( ^) x6 g- w6 e) J回到这个函数稍微改一下

1. uint8_t ETH_MAC_Setting(ETH_HandleTypeDef *heth)
   
2. {
   
3.     ETH_MACInitTypeDef macinit;
   
4.     /* Ethernet MAC default initialization **************************************/
   
5.     macinit.Watchdog = ETH_WATCHDOG_ENABLE;
   
6.     macinit.Jabber = ETH_JABBER_ENABLE;
   # t+ D2 G, j1 o/ q, F
7.     macinit.InterFrameGap = ETH_INTERFRAMEGAP_96BIT;
   % e, O: V2 E0 J( g/ L+ @6 J
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)
    4 ~& V: t) V0 b* U+ d
12.     {
    
13.         macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_ENABLE;
    
14.     }
    
15.     else
    
16.     {
    " [: u3 J8 z! R9 s
17.         macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_DISABLE;
    % r0 x3 t) R% f; g) u0 z& a
18.     }
    
19.     macinit.RetryTransmission = ETH_RETRYTRANSMISSION_ENABLE;          //使能重传
    
20.     macinit.AutomaticPadCRCStrip = ETH_AUTOMATICPADCRCSTRIP_ENABLE;          //使能自动去除
    + E$ M" T, t# G8 g
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; //源地址过滤
    / J1 {2 U% i0 {0 U$ Y% P( t! A
25.     macinit.PassControlFrames = ETH_PASSCONTROLFRAMES_BLOCKALL;
    $ o5 `! ~( X6 j" z" b' |- H
26.     macinit.BroadcastFramesReception = ETH_BROADCASTFRAMESRECEPTION_DISABLE; //广播不接收
    / i6 Y: O4 {* I7 m; ?0 Y' ?$ H2 U
27.     macinit.DestinationAddrFilter = ETH_DESTINATIONADDRFILTER_NORMAL; //目的地址过滤
    
28.     macinit.PromiscuousMode = ETH_PROMISCUOUS_MODE_DISABLE; //混乱模式
    ; h! Q' b  M9 |% ?9 e
29.     macinit.MulticastFramesFilter = ETH_MULTICASTFRAMESFILTER_PERFECTHASHTABLE; //！！多播HASH完美过滤
    7 f& _; n" [5 \( |2 {$ b
30.     macinit.UnicastFramesFilter = ETH_UNICASTFRAMESFILTER_PERFECTHASHTABLE; //！！单播HASH完美过滤
    ) }0 `3 }  k/ G0 p; n$ B+ b
31.     macinit.HashTableHigh = 0x0; //！！填你最后算完的Hash表高位
    5 z* b2 T1 C6 k2 n) m" i
32.     macinit.HashTableLow = 0x0; //！！填你最后算完的Hash表低位
    1 a7 ?& J, B/ D/ y$ ]
33.     macinit.PauseTime = 0x0;
    5 G/ R8 l) B1 ~4 f- m2 V( W
34.     macinit.ZeroQuantaPause = ETH_ZEROQUANTAPAUSE_DISABLE;
    
35.     macinit.PauseLowThreshold = ETH_PAUSELOWTHRESHOLD_MINUS4;
    
36.     macinit.UnicastPauseFrameDetect = ETH_UNICASTPAUSEFRAMEDETECT_ENABLE;
    - ]1 P- X0 j& x
37.     macinit.ReceiveFlowControl = ETH_RECEIVEFLOWCONTROL_DISABLE; //接收流控
    + Y  u$ E0 l8 _& l. o/ |3 |% Z
38.     macinit.TransmitFlowControl = ETH_TRANSMITFLOWCONTROL_DISABLE; //发送流控
    
39.     macinit.VLANTagComparison = ETH_VLANTAGCOMPARISON_16BIT;
    + V! `, k/ O* ^% e
40.     macinit.VLANTagIdentifier = 0x0;
    4 ?1 w- W  O& i6 p
41. 
    4 U( y/ @3 O: i( H% P( _2 E' I
42.     return HAL_ETH_ConfigMAC(heth, &macinit);
    
43. }

复制代码

& I4 A. {" r! X, A! u" }0 J$ f9 J大概MAC层过滤就这些东西了
. y+ R( @$ a7 d& I) k/ Y如果有条件弄MAC层过滤真的强烈建议开启，可以大幅减轻协议栈的处理负担，板卡不会因为处理大量无用的数据而白白浪费处理性能。
3 u7 E0 L: i% F# n9 o: P  X
$ |$ ]2 I% |7 ]& E( F' V8 `

& V- ]! l/ o  X3 `( t
; |0 f* O' t* l