前景描述
6 n  L+ r8 s3 E" H3 T% L, x我司的以太网实现是LAN8720搭配片上MAC层做的，协议栈用LWIP
! @  E/ n/ R+ d' f0 [
这种做法应该还是蛮常见的，反正不是LAN8720就是DP83864，再不然就是硬件协议栈的W5500了
8 C# F" o- P& A; |- g/ \
+ I4 R5 j) D2 K2 J8 Q+ I$ w1 A( q+ ]想想还是有MAC层过滤比较好，随手翻了翻它的手册，W5500好像是没得MAC层过滤的

5 r" v; i8 p) t! q假如数据速率比较高，数据量大，而且外面还有乱七八糟无关的数据往板卡送，我也不知道用这个片子到底好不好
7 F" Q$ }) u; A, J/ |( Y% p% A
LAN8720也不好改了，就继续用吧
5 l* a% q5 p4 v
好好在，发给板卡的数据的MAC还是有特征的，我只需要过滤发送方MAC地址的前3个字节，也就是特定的厂家那段
2 L/ M1 [, f8 _( p4 U
MAC地址的科普知识这里就不过多描述了，我们直奔主题
# m0 p' K0 O) g& B* I
6 L) R! ]8 q+ I7 U怎么用STM32 F7的片上MAC做MAC层过滤
, M# u; h4 A/ H
写这个的目的，就是我搜了搜，没看见有人写这个MAC层过滤功能，具体代码怎么写才能用

7 z4 M% K- d# t) K7 A知识科普-STM32的片上MAC
& s" g7 W2 R# S# P' b1 B% bSTM32 F7的MAC层过滤方式有三种(说人话的直白解释，中文手册其实也翻译的不好)
% Z0 {) I& D' l5 \精确过滤(手册上叫单播目标/源地址过滤)
粗糙过滤(手册上叫Hash表过滤)
特殊过滤(广播，组播过滤等等特殊的过滤)
* D% P; z* Y9 Q  J, _) [7 P& C我这里着重说第1种和第3种

STM32 F7可以存4个MAC地址
/ J6 z2 g( r. _; ]5 y6 J- Z( l其中MAC地址0是自己的MAC，其他三个可以用来做过滤

网络数据包通过PHY进入STM32的MAC，MAC层是可以对目的地址/源地址检查并过滤掉没得用的数据的，默认的HAL库库函数HAL_ETH_Init中
2 M1 P0 O8 W" Q  o有一个static的函数
! d, r0 O; t7 g0 `  ]0 V9 U, astatic void ETH_MACDMAConfig(ETH_HandleTypeDef *heth, uint32_t err)
会帮你在初始化网络功能时初始化默认的MAC层功能:
关闭源地址过滤
* A# z: |- }7 M不接收所有数据
& O" @) i/ B% I. g# Y接收广播帧
' N2 ^# O& q4 d1 H6 t7 B5 k3 f打开目的地地址过滤
单播数据精确过滤
组播数据精确过滤
1 A. w: j2 m/ \Hash表过滤关闭
  w' u7 C% U0 \
6 n+ R# ]- u6 A+ i7 |6 d% i+ j其他的功能自行研究，我这里捡重要的说
; c, o) q0 ~& d& a6 z- Q7 q9 \

1. static void ETH_MACDMAConfig(ETH_HandleTypeDef *heth, uint32_t err)
   $ q# b# l. H7 x/ O9 C
2. {
   
3. ETH_MACInitTypeDef macinit;
   
4. ETH_DMAInitTypeDef dmainit;
   ! R: k- U* S4 o8 Y  m
5. uint32_t tmpreg = 0;
   
6. 
   & o+ P; a3 G" e' I) \6 D: K5 E
7. if (err != ETH_SUCCESS) /* Auto-negotiation failed */
   
8. {
   / E0 L: b/ I8 y
9. /* Set Ethernet duplex mode to Full-duplex */
   % f# E& s' ]* n6 ]& @7 m; X( n, U
10. (heth->Init).DuplexMode = ETH_MODE_FULLDUPLEX;
    
11. 
    
12. /* Set Ethernet speed to 100M */
    " U8 f: a. x/ {' o! ^2 m
13. (heth->Init).Speed = ETH_SPEED_100M;
    
14. }
    " ?. H# e) @* j+ j' N
15. 
    2 i9 Z: K% i! r! ?  T
16. /* Ethernet MAC default initialization **************************************/
    $ j( K% ^8 Z, i( Q9 D& Q. ?" [& c
17. macinit.Watchdog = ETH_WATCHDOG_ENABLE;
    
18. macinit.Jabber = ETH_JABBER_ENABLE;
    : a" f" V3 [% c# K  D
19. macinit.InterFrameGap = ETH_INTERFRAMEGAP_96BIT;
    8 A' q9 d6 s+ e5 e4 {
20. macinit.CarrierSense = ETH_CARRIERSENCE_ENABLE;
    # T1 J0 E; D% H- L. h
21. macinit.ReceiveOwn = ETH_RECEIVEOWN_ENABLE;
    , Y8 }; N' l4 q3 _  H' W* F) P
22. macinit.LoopbackMode = ETH_LOOPBACKMODE_DISABLE;
    1 J( S$ A& H% x4 t  c5 X3 U; q
23. if(heth->Init.ChecksumMode == ETH_CHECKSUM_BY_HARDWARE)
    , k5 c, u; _# C7 L3 r( L
24. {
    
25. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_ENABLE;
    
26. }
    5 t# e7 Q$ Y1 ?  z1 T
27. else
    1 _2 `$ W! N4 h8 M+ G
28. {
    7 Y$ b+ f( y6 ~! [
29. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_DISABLE;
    
30. }
    # @4 r& ?, F6 H3 i) e
31. //这一段是MAC层过滤的设置，下面是DMA的，那个用默认的就可以
    % V8 l% S. h0 t8 ~9 K: w6 a# _3 r
32. macinit.RetryTransmission = ETH_RETRYTRANSMISSION_DISABLE;
    
33. macinit.AutomaticPadCRCStrip = ETH_AUTOMATICPADCRCSTRIP_DISABLE;
    . K; c" \  y5 h7 Y+ j
34. macinit.BackOffLimit = ETH_BACKOFFLIMIT_10;
    
35. macinit.DeferralCheck = ETH_DEFFERRALCHECK_DISABLE;
    
36. macinit.ReceiveAll = ETH_RECEIVEAll_DISABLE;
    
37. macinit.SourceAddrFilter = ETH_SOURCEADDRFILTER_DISABLE;
    ( E3 D# n0 G8 U  x# _$ i
38. macinit.PassControlFrames = ETH_PASSCONTROLFRAMES_BLOCKALL;
    3 `. d, d6 C  |# L1 F7 t' s# \
39. macinit.BroadcastFramesReception = ETH_BROADCASTFRAMESRECEPTION_ENABLE;
    ) z$ k2 A+ o6 ~1 }$ L
40. macinit.DestinationAddrFilter = ETH_DESTINATIONADDRFILTER_NORMAL;
    
41. macinit.PromiscuousMode = ETH_PROMISCUOUS_MODE_DISABLE;
    . B$ E' t) x, B+ ~) y# ~) b
42. macinit.MulticastFramesFilter = ETH_MULTICASTFRAMESFILTER_PERFECT;
      B5 a/ }) }- I; n8 a% G
43. macinit.UnicastFramesFilter = ETH_UNICASTFRAMESFILTER_PERFECT;
    9 z! F& o7 [( @3 Q& p' i$ G# ^
44. macinit.HashTableHigh = 0x0;
    " R* A) q  c- C7 ~! ?
45. macinit.HashTableLow = 0x0;
    
46. macinit.PauseTime = 0x0;
    
47. macinit.ZeroQuantaPause = ETH_ZEROQUANTAPAUSE_DISABLE;
    / B9 t# Q! s8 `" ^! @7 N. b
48. macinit.PauseLowThreshold = ETH_PAUSELOWTHRESHOLD_MINUS4;
    , b, J7 @2 x# f# ^% \
49. macinit.UnicastPauseFrameDetect = ETH_UNICASTPAUSEFRAMEDETECT_DISABLE;
    7 F2 ]" l, a  [3 v, P
50. macinit.ReceiveFlowControl = ETH_RECEIVEFLOWCONTROL_DISABLE;
    , X4 |5 Q2 Z$ u6 @+ s
51. macinit.TransmitFlowControl = ETH_TRANSMITFLOWCONTROL_DISABLE;
    
52. macinit.VLANTagComparison = ETH_VLANTAGCOMPARISON_16BIT;
    2 ]  v; ?+ c" C" q- k0 H# [
53. macinit.VLANTagIdentifier = 0x0;
    5 E, Z) E( h; U+ t& ~
54. 
    ' u7 K% Y2 ^; W
55. /*------------------------ ETHERNET MACCR Configuration --------------------*/
    " q. W) J9 c& `4 Z9 F$ r: E/ Z, E
56. /* Get the ETHERNET MACCR value */
    7 z& L+ j- b% S6 Z& q
57. tmpreg = (heth->Instance)->MACCR;
    0 k1 I9 @5 F" B3 A) H
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 */
    
61. /* Set the JD: bit according to ETH Jabber value */
    / W8 t7 O$ M3 E9 E* i4 D2 ^
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 */
    % _5 Q. F. T! Y6 ^# d
65. /* Set the DO bit according to ETH ReceiveOwn value */
    
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 */
    
69. /* Set the DR bit according to ETH RetryTransmission value */
    
70. /* Set the ACS bit according to ETH AutomaticPadCRCStrip value */
    * G% J* e) f' H" C! Q5 Y9 W( M* E
71. /* Set the BL bit according to ETH BackOffLimit value */
    
72. /* Set the DC bit according to ETH DeferralCheck value */
    ) t; h& s" t2 j- H9 W
73. tmpreg |= (uint32_t)(macinit.Watchdog |
    
74. macinit.Jabber |
    3 p8 ^& V9 G* j4 C4 ?( n
75. macinit.InterFrameGap |
    7 d1 g7 Y, B% x6 J
76. macinit.CarrierSense |
    
77. (heth->Init).Speed |
    " V7 h  S( v3 y& D) a3 ?
78. macinit.ReceiveOwn |
    
79. macinit.LoopbackMode |
    2 [. B5 ]3 ?1 ~' M+ ^
80. (heth->Init).DuplexMode |
    
81. macinit.ChecksumOffload |
    
82. macinit.RetryTransmission |
    0 l3 q& I( Q2 b
83. macinit.AutomaticPadCRCStrip |
    
84. macinit.BackOffLimit |
    - K% [) _0 q" z
85. macinit.DeferralCheck);
    ) n: @# K$ G9 g6 D7 x# B" R; O! i
86. 
    
87. /* Write to ETHERNET MACCR */
    
88. (heth->Instance)->MACCR = (uint32_t)tmpreg;
    9 \, X' Z4 M$ w! J" \
89. 
    . w( F8 m7 T5 x- w2 G/ h3 t: ?! G% B! j
90. /* Wait until the write operation will be taken into account:
      Q5 T  G& T: b5 c5 d
91. at least four TX_CLK/RX_CLK clock cycles */
    ; b& ]: B+ m( o0 Q' q
92. tmpreg = (heth->Instance)->MACCR;
    
93. HAL_Delay(ETH_REG_WRITE_DELAY);
    * n. `' Y* _3 u4 ^' E; ?. G
94. (heth->Instance)->MACCR = tmpreg;
    4 V7 q2 k+ S$ `) F" ?) [
95. 
    
96. /*----------------------- ETHERNET MACFFR Configuration --------------------*/
    , l' A5 m. a! z- b
97. /* Set the RA bit according to ETH ReceiveAll value */
    
98. /* Set the SAF and SAIF bits according to ETH SourceAddrFilter value */
    
99. /* Set the PCF bit according to ETH PassControlFrames value */
    4 Z" f7 ]2 n6 Q) ]# \
100. /* Set the DBF bit according to ETH BroadcastFramesReception value */
     $ z3 C2 E! T$ X4 J  U# H
101. /* Set the DAIF bit according to ETH DestinationAddrFilter value */
     
102. /* Set the PR bit according to ETH PromiscuousMode value */
     
103. /* Set the PM, HMC and HPF bits according to ETH MulticastFramesFilter value */
     
104. /* Set the HUC and HPF bits according to ETH UnicastFramesFilter value */
     
105. /* Write to ETHERNET MACFFR */
     ; l/ z( M, Z! F& L1 C
106. (heth->Instance)->MACFFR = (uint32_t)(macinit.ReceiveAll |
     
107. macinit.SourceAddrFilter |
     
108. macinit.PassControlFrames |
     $ |4 M" Q& B. s; I' l* h
109. macinit.BroadcastFramesReception |
     
110. macinit.DestinationAddrFilter |
     
111. macinit.PromiscuousMode |
     * L, Q& i4 X' Q: G1 C4 x3 G
112. macinit.MulticastFramesFilter |
     # Q  x7 H7 k/ R2 I) s
113. macinit.UnicastFramesFilter);
     ; Q4 m0 y- q% k% W! H+ r% w
114. 
       s$ n0 F4 K: ?' ]! Y
115. /* Wait until the write operation will be taken into account:
     - V. z: i9 j2 `% {1 o2 ]9 N
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;
     
120. 
     
121. /*--------------- ETHERNET MACHTHR and MACHTLR Configuration --------------*/
     
122. /* Write to ETHERNET MACHTHR */
     
123. (heth->Instance)->MACHTHR = (uint32_t)macinit.HashTableHigh;
     ! C) r5 n# J, Y* ]/ U! q' t% u
124. 
     
125. /* Write to ETHERNET MACHTLR */
     
126. (heth->Instance)->MACHTLR = (uint32_t)macinit.HashTableLow;
     
127. /*----------------------- ETHERNET MACFCR Configuration -------------------*/
     " D6 a* d; y, G
128. 
     , j8 R0 ?$ U* r( H- v4 }. L
129. /* Get the ETHERNET MACFCR value */
     1 s$ O; b1 U1 W& k8 e1 E  T
130. tmpreg = (heth->Instance)->MACFCR;
     
131. /* Clear xx bits */
     
132. tmpreg &= ETH_MACFCR_CLEAR_MASK;
     4 i" m; L" H$ @
133. 
     - ]: E, [" ^8 Q  Y6 P* p- h
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 */
     
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:
     
143. at least four TX_CLK/RX_CLK clock cycles */
     
144. tmpreg = (heth->Instance)->MACFCR;
     ; J7 ], n( B2 x0 w6 W+ w7 C
145. HAL_Delay(ETH_REG_WRITE_DELAY);
     
146. (heth->Instance)->MACFCR = tmpreg;
     - J) y/ w0 m7 e+ k8 z- g
147. 
     
148. /*----------------------- ETHERNET MACVLANTR Configuration ----------------*/
     
149. /* Set the ETV bit according to ETH VLANTagComparison value */
     3 U% I" d8 u1 \+ G
150. /* Set the VL bit according to ETH VLANTagIdentifier value */
     5 I3 b; n0 `( N, ^1 _/ a
151. (heth->Instance)->MACVLANTR = (uint32_t)(macinit.VLANTagComparison |
     
152. macinit.VLANTagIdentifier);
     ( L+ m, J0 Z/ Q: O4 {
153. 
     
154. /* Wait until the write operation will be taken into account:
     6 B6 f2 o. w; ]  o3 a; v( F
155.    at least four TX_CLK/RX_CLK clock cycles */
     + C! u: ?2 E% c7 q, s2 Q+ q7 g
156. tmpreg = (heth->Instance)->MACVLANTR;
     ) G3 Y# W( W3 _2 |5 O# q1 U
157. HAL_Delay(ETH_REG_WRITE_DELAY);
     
158. (heth->Instance)->MACVLANTR = tmpreg;
     
159. 
     
160. /* Ethernet DMA default initialization ************************************/
     6 u0 G# y) R* e  E
161. dmainit.DropTCPIPChecksumErrorFrame = ETH_DROPTCPIPCHECKSUMERRORFRAME_ENABLE;
     
162. dmainit.ReceiveStoreForward = ETH_RECEIVESTOREFORWARD_ENABLE;
     
163. dmainit.FlushReceivedFrame = ETH_FLUSHRECEIVEDFRAME_ENABLE;
     ; Y+ E9 v/ ^3 I: f% I
164. dmainit.TransmitStoreForward = ETH_TRANSMITSTOREFORWARD_ENABLE;
     8 l4 `( D9 y8 A0 a. B* q7 q: L
165. dmainit.TransmitThresholdControl = ETH_TRANSMITTHRESHOLDCONTROL_64BYTES;
     " d+ t7 F2 f( J2 G
166. dmainit.ForwardErrorFrames = ETH_FORWARDERRORFRAMES_DISABLE;
     " m5 Q1 ?0 t" p* {8 |
167. dmainit.ForwardUndersizedGoodFrames = ETH_FORWARDUNDERSIZEDGOODFRAMES_DISABLE;
     6 ~9 g0 N. U- |' {. c# J! u
168. dmainit.ReceiveThresholdControl = ETH_RECEIVEDTHRESHOLDCONTROL_64BYTES;
     
169. dmainit.SecondFrameOperate = ETH_SECONDFRAMEOPERARTE_ENABLE;
     & j' ^# ?- A' F  U; p+ N
170. dmainit.AddressAlignedBeats = ETH_ADDRESSALIGNEDBEATS_ENABLE;
     
171. dmainit.FixedBurst = ETH_FIXEDBURST_ENABLE;
     . ?5 P. ^% M. S; D
172. dmainit.RxDMABurstLength = ETH_RXDMABURSTLENGTH_32BEAT;
     ( c, _3 l4 z7 \% ]
173. dmainit.TxDMABurstLength = ETH_TXDMABURSTLENGTH_32BEAT;
     
174. dmainit.EnhancedDescriptorFormat = ETH_DMAENHANCEDDESCRIPTOR_ENABLE;
     
175. dmainit.DescriptorSkipLength = 0x0;
     
176. dmainit.DMAArbitration = ETH_DMAARBITRATION_ROUNDROBIN_RXTX_1_1;
     , q$ |8 V; w0 Y3 M6 @
177. 
     
178. /* Get the ETHERNET DMAOMR value */
     ( e: Z+ @4 ~& L. I+ G% U
179. tmpreg = (heth->Instance)->DMAOMR;
     % j4 |$ Y4 \5 @4 X- r
180. /* Clear xx bits */
     
181. tmpreg &= ETH_DMAOMR_CLEAR_MASK;
     ) S- J  c$ p  w1 v5 s! W
182. 
     
183. /* Set the DT bit according to ETH DropTCPIPChecksumErrorFrame value */
     3 K2 U. D. n7 g' `5 I+ _. h* j' K& q* v
184. /* Set the RSF bit according to ETH ReceiveStoreForward value */
     
185. /* Set the DFF bit according to ETH FlushReceivedFrame value */
     
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 */
     3 C" k  J7 b: G
189. /* Set the FUF bit according to ETH ForwardUndersizedGoodFrames value */
     . i! G' c0 [+ D! s
190. /* Set the RTC bit according to ETH ReceiveThresholdControl value */
     
191. /* Set the OSF bit according to ETH SecondFrameOperate value */
     3 t: L! D2 K* D( B
192. tmpreg |= (uint32_t)(dmainit.DropTCPIPChecksumErrorFrame |
     3 J! P. a7 h! u& `. f0 V0 M6 F9 A
193.                      dmainit.ReceiveStoreForward |
     
194.                      dmainit.FlushReceivedFrame |
     ; h! g3 e- Q6 l6 S. }
195.                      dmainit.TransmitStoreForward |
     
196.                      dmainit.TransmitThresholdControl |
     7 D3 c; s: f$ e2 g' ?* ~
197.                      dmainit.ForwardErrorFrames |
     " h, `7 ^+ a9 K3 w# M7 c* a
198.                      dmainit.ForwardUndersizedGoodFrames |
     " H! ^. j6 B/ p8 s
199.                      dmainit.ReceiveThresholdControl |
     
200.                      dmainit.SecondFrameOperate);
     # b' }7 @8 d% i+ I7 A
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:
     6 t6 f. N% }6 e; p
206.    at least four TX_CLK/RX_CLK clock cycles */
     # }; q  ^1 {" d  y
207. tmpreg = (heth->Instance)->DMAOMR;
     
208. HAL_Delay(ETH_REG_WRITE_DELAY);
     
209. (heth->Instance)->DMAOMR = tmpreg;
     % H/ D0 M+ Q) ?3 I0 ?$ Q9 n: p
210. 
     * e. L" Z$ q2 D0 h7 v
211. /*----------------------- ETHERNET DMABMR Configuration ------------------*/
     
212. /* Set the AAL bit according to ETH AddressAlignedBeats value */
     . X3 {- h5 i- t5 F9 E4 z
213. /* Set the FB bit according to ETH FixedBurst value */
     / P: ^0 R2 ?$ T7 Z8 L! d7 E: h; E
214. /* Set the RPBL and 4*PBL bits according to ETH RxDMABurstLength value */
     & T# j& i5 i0 I9 J* E  t9 B' b6 B
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*/
     " X1 o' H7 R! k4 m
217. /* Set the DSL bit according to ETH DesciptorSkipLength value */
     
218. /* Set the PR and DA bits according to ETH DMAArbitration value */
     1 G* I- ~  [3 _9 ]
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 */
     : r3 ^0 w" n2 e, z9 o) S2 a& m
222.                                       dmainit.TxDMABurstLength |
     3 ^0 b) ]) D) a$ X( L+ T0 Q: X
223.                                       dmainit.EnhancedDescriptorFormat |
     7 S& c- b7 T' L: q7 H
224.                                       (dmainit.DescriptorSkipLength Instance)->DMABMR;
     4 |- C9 O4 b% w8 z1 b- P- W% Y
225. HAL_Delay(ETH_REG_WRITE_DELAY);
     , p1 Y$ N" e- u: Q' I; i
226. (heth->Instance)->DMABMR = tmpreg;
     ! k4 X6 r! V" p, g, y+ h
227. 
     9 D! {, M+ D5 x5 \: l
228. if((heth->Init).RxMode == ETH_RXINTERRUPT_MODE)
     
229. {
     4 _- o$ ?) f' o$ J
230.    /* Enable the Ethernet Rx Interrupt */
     2 E$ s% X$ M& @% ?
231.    __HAL_ETH_DMA_ENABLE_IT((heth), ETH_DMA_IT_NIS | ETH_DMA_IT_R);
     
232. }
     
233. 
     2 L1 l& {6 U7 q7 @# R
234. /* Initialize MAC address in ethernet MAC */
     
235. ETH_MACAddressConfig(heth, ETH_MAC_ADDRESS0, heth->Init.MACAddr);
     $ R7 l: A' w0 @8 v, }; Z
236. }

复制代码

# b, Z+ a: w$ Q2 a这里我就要稍微吐槽一下HAL库了
MAC层过滤的设置没有预留接口出来，有设置MAC地址的函数
( d. q4 ~  q: f
static void ETH_MACAddressConfig(ETH_HandleTypeDef *heth, uint32_t MacAddr, uint8_t *Addr)
' |. G& w. s; e; k. S
! |# s3 f3 X3 {" g( s4 p就不多做一个设置MAC层过滤的函数嘛，连后面用到的宏定义都有~~

9 a* p6 {3 W% |6 v7 F' H3 d木有办法，自己编一个初始化MAC层过滤的函数吧
9 j# n& m" X- \; f4 ?7 {
5 ^! q* J+ \& U/ w1 t# l其实也就是把上面这个ETH_MACDMAConfig函数分离成两个单独的设置函数，再编一个设置MAC层过滤的函数

. ~" W6 ^! s3 ^# I4 u开启MAC层过滤的初始化代码

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;
   * Q9 A5 K2 l/ }9 p7 h
6. macinit.Jabber = ETH_JABBER_ENABLE;
   
7. macinit.InterFrameGap = ETH_INTERFRAMEGAP_96BIT;
   
8. macinit.CarrierSense = ETH_CARRIERSENCE_ENABLE;
   
9. macinit.ReceiveOwn = ETH_RECEIVEOWN_ENABLE;
   , ]0 O% U( F5 `8 S; U
10. macinit.LoopbackMode = ETH_LOOPBACKMODE_DISABLE;
    7 {' O. o0 e& K1 f8 N" `
11. if (heth->Init.ChecksumMode == ETH_CHECKSUM_BY_HARDWARE)
    
12. {
    
13. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_ENABLE;
    
14. }
    8 r. r! s7 T1 d2 X
15. else
    . v2 y' L$ e) c8 Y: E- D
16. {
    
17. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_DISABLE;
    
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;
    & g; U, D; K$ g( Z2 b" o/ E  `$ D
23. macinit.ReceiveAll = ETH_RECEIVEAll_DISABLE; ///不接收所有包
    7 I1 p& a$ V, ]6 _8 t
24. macinit.SourceAddrFilter = ETH_SOURCEADDRFILTER_NORMAL_ENABLE; //源地址过滤
    
25. macinit.PassControlFrames = ETH_PASSCONTROLFRAMES_BLOCKALL;
    4 n# G& H& S* U
26. macinit.BroadcastFramesReception = ETH_BROADCASTFRAMESRECEPTION_DISABLE; //广播不接收
    
27. macinit.DestinationAddrFilter = ETH_DESTINATIONADDRFILTER_NORMAL; //目的地址过滤
    & f( U. p- p1 o- J
28. macinit.PromiscuousMode = ETH_PROMISCUOUS_MODE_DISABLE; //混乱模式
    
29. macinit.MulticastFramesFilter = ETH_MULTICASTFRAMESFILTER_PERFECT; //多播过滤
    
30. macinit.UnicastFramesFilter = ETH_UNICASTFRAMESFILTER_PERFECT; //单播过滤
    
31. macinit.HashTableHigh = 0x0; //Hash表高位
    . d3 v; Y( t  n0 o' ~, G
32. macinit.HashTableLow = 0x0; //Hash表低位
    
33. macinit.PauseTime = 0x0;
    
34. macinit.ZeroQuantaPause = ETH_ZEROQUANTAPAUSE_DISABLE;
    
35. macinit.PauseLowThreshold = ETH_PAUSELOWTHRESHOLD_MINUS4;
    
36. macinit.UnicastPauseFrameDetect = ETH_UNICASTPAUSEFRAMEDETECT_ENABLE;
    ( o/ ^' X0 ?3 I" w3 g3 n
37. macinit.ReceiveFlowControl = ETH_RECEIVEFLOWCONTROL_DISABLE; //接收流控
    ' |' ]; g" [4 U6 |1 W2 U6 B; t
38. macinit.TransmitFlowControl = ETH_TRANSMITFLOWCONTROL_DISABLE; //发送流控
    & R- ~1 w" h, |3 I) G+ f4 D: V
39. macinit.VLANTagComparison = ETH_VLANTAGCOMPARISON_16BIT;
    9 T& X/ k# x8 K5 L1 \9 g
40. macinit.VLANTagIdentifier = 0x0;
    : {1 K% f1 |7 P
41. 
    6 O1 v9 a( ?0 T; U
42. return HAL_ETH_ConfigMAC(heth, &macinit);
    
43. }

复制代码

默认的MAC层 DMA初始化函数
: T! J. V7 I8 z( c! a

1. uint8_t ETH_DMA_Setting(ETH_HandleTypeDef *heth)
   
2. {
   * F7 f3 t8 N1 i2 d# c& Y! B
3. ETH_DMAInitTypeDef dmainit;
   ! h/ p) m3 G1 D2 n, s4 ^6 Y5 H
4. /* Ethernet DMA default initialization ************************************/
   ; F7 M' H, V3 k+ y( [. }
5. dmainit.DropTCPIPChecksumErrorFrame = ETH_DROPTCPIPCHECKSUMERRORFRAME_ENABLE;
   ( R, T; \* ?7 \# w
6. dmainit.ReceiveStoreForward = ETH_RECEIVESTOREFORWARD_ENABLE;
   4 G4 ?" a/ a' t. g  w
7. dmainit.FlushReceivedFrame = ETH_FLUSHRECEIVEDFRAME_ENABLE;
   
8. dmainit.TransmitStoreForward = ETH_TRANSMITSTOREFORWARD_ENABLE;
   ) U9 x+ k7 [, ]
9. dmainit.TransmitThresholdControl = ETH_TRANSMITTHRESHOLDCONTROL_64BYTES;
   
10. dmainit.ForwardErrorFrames = ETH_FORWARDERRORFRAMES_DISABLE;
    
11. dmainit.ForwardUndersizedGoodFrames = ETH_FORWARDUNDERSIZEDGOODFRAMES_DISABLE;
    ( v7 ^  D/ l! y6 L! ]
12. dmainit.ReceiveThresholdControl = ETH_RECEIVEDTHRESHOLDCONTROL_64BYTES;
    , }; T( N! v( b& J% `
13. dmainit.SecondFrameOperate = ETH_SECONDFRAMEOPERARTE_ENABLE;
    
14. dmainit.AddressAlignedBeats = ETH_ADDRESSALIGNEDBEATS_ENABLE;
    
15. dmainit.FixedBurst = ETH_FIXEDBURST_ENABLE;
    / \* v+ F% g/ Z. G/ L" ~
16. dmainit.RxDMABurstLength = ETH_RXDMABURSTLENGTH_32BEAT;
    
17. dmainit.TxDMABurstLength = ETH_TXDMABURSTLENGTH_32BEAT;
    6 G8 |- S; l2 ?2 g, ], C0 T' o
18. dmainit.EnhancedDescriptorFormat = ETH_DMAENHANCEDDESCRIPTOR_ENABLE;
    
19. dmainit.DescriptorSkipLength = 0x0;
    : @3 w6 j; u8 f" p8 J
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)
    & u+ Q' V  e8 w0 V
23. {
    2 S! y9 C& Z5 }4 [3 }
24. /* Enable the Ethernet Rx Interrupt */
    
25. __HAL_ETH_DMA_ENABLE_IT((heth), ETH_DMA_IT_NIS | ETH_DMA_IT_R);
    
26. }
    
27. return res;
    
28. }

复制代码

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

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

复制代码

然后到最最重要的MAC层过滤设置
+ W: }4 ^* f( l; n以MAC1为例
- F* q- d" Q' B  M

' S- ~) b  {- u. `
注意看红框的描述
功能很好用，可以过滤源地址/目的地址，还可以做掩码功能
设置MAC层过滤的代码
$ y: f  P; u8 W$ o# A  c4 c0 W. L9 |

1. static void ETH_MAC_Filter_Setting(ETH_HandleTypeDef *heth,ST_ETH_PAR * para)
   
2. {
   4 H3 @. H2 ]3 D7 h0 r; x9 U
3.     //设置本机MAC地址
   
4.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS0, heth->Init.MACAddr);
   
5.     //设置UDP-A的对方MAC地址
   
6.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS1,para->UDP_A_MAC);
   
7.     (heth->Instance)->MACA1HR|=0xC0000000;//需要完全匹配UDP-A的对方MAC才接收
   
8.     //设置UDP-B的对方MAC地址
   
9.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS2,para->UDP_B_MAC);
   
10.     (heth->Instance)->MACA2HR|=0xC0000000;//需要完全匹配UDP-A的对方MAC才接收
    
11. }

复制代码

我这里是希望为我的两个UDP精确过滤接收到的源地址
& M7 @4 s/ }: w所以AE位设置为1，SA设置为1，MBC全部为0(MAC地址全部检查)
. f8 G: j) b" c
假如我希望过滤MAC中特定的厂家字段
4 w0 Y. e8 U; f+ {& ^! i例如某个MAC地址
# }- e/ k* ~! G01-02-03-04-05-06
4 L, U% I* s5 i其中01-02-03就是厂家字段
. \  a4 I$ h# ]' a
4 g5 A% X7 w( ^: ]  X3 M. T那么代码要这样修改（MBC的第29位，28位，27位置1）
这样MAC层就不会检查MAC地址里后3个字节(04-05-06)
  s, k$ L- K0 t' T2 ?% y但是会检查前3个字节，也就是厂家字段
这里需要注意MAC地址的字节序

1. static void ETH_MAC_Filter_Setting(ETH_HandleTypeDef *heth,ST_ETH_PAR * para)
   9 o% P* m" _  x
2. {
   / l% ~. u7 J. v& F$ h
3.     //设置本机MAC地址
   ; j4 Q- c2 Y. F6 ~7 s
4.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS0, heth->Init.MACAddr);
   
5.     //设置UDP-A的对方MAC地址
   
6.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS1,para->UDP_A_MAC);
   8 X. R9 [6 ?) o6 X, A7 f: g) @% S, j# A
7.     (heth->Instance)->MACA1HR|=0xF8000000;//需要匹配厂家字段
   " N# g% C* E- ]' h4 n
8.     //设置UDP-B的对方MAC地址
     O3 m5 {! q3 G0 i
9.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS2,para->UDP_B_MAC);
   * y( L2 t( Q2 [! h: N
10.     (heth->Instance)->MACA2HR|=0xF8000000;//需要匹配厂家字段
    
11. }

复制代码

然后这些函数的调用顺序按:
* K& A2 c) D& y0 h: P1. HAL_ETH_Init
2. ETH_MAC_Setting
4 p9 Q0 x" x3 ]; B' W6 k3. ETH_DMA_Setting
4. ETH_MAC_Filter_Setting

用你希望过滤的MAC传递到一个Hash计算函数里，得到一个值，通过这个值产生“映射”关系来过滤MAC地址，所以这个并不是精确的，因为可能会重复~~
9 l; y* Q# ^2 E; [
7 m# d3 Z! P4 }HASH函数
8 l9 f8 }4 S5 P* p/ b1 v函数

1. / STM32 MACHASH - Copyright (C) 2014-2018 Clive Turvey (<a href="mailto:sourcer32@gmail.com">sourcer32@gmail.com</a>)
   
2. //  All Rights Reserved
   % m4 J5 D5 D* M
3. 
   , {; v- X& n. L6 P4 `+ d5 M' v
4. #include <windows.h>
   
5. 
   
6. #include <stdio.h>
     p" P' \: I* u/ F7 ~' K+ l; t
7. #include <stdlib.h>
   
8. 
   
9. typedef unsigned char uint8_t;
   
10. typedef unsigned long uint32_t;
    
11. 
    
12. uint32_t Rev32(uint32_t x)
    # a. p! x9 P5 s) s/ H6 ?$ C
13. {
    
14.   uint32_t y;
    
15.   int i;
    
16. 
    5 m$ \  G1 v+ ~* N
17.   y = 0;
    ! H. z/ s1 g( O( M, p
18. 
    ' p$ N/ {9 ]9 W$ ?$ o
19.   for(i=0; i<32; i++)
    * b3 _% v: C! G, `. z
20.     if (x & (1 << i))
    ; o: c/ L0 k1 y2 o
21.       y |= 1 << (31 - i);
    4 P1 R* k8 M! Q# ?# w
22. 
    
23.   return(y);
    * m( P: o8 G- ^. G7 J6 N! r
24. }
    ' o- G0 \) W7 x! I1 I' C
25. 
    
26. uint32_t MacHash(const uint8_t *Mac) // <a href="mailto:sourcer32@gmail.com">sourcer32@gmail.com</a>
    
27. {
    0 z/ W. f# ~' B* }1 C8 f+ t$ a
28.   int i, j;
    
29.   uint32_t Crc;
    8 r% t2 z0 |, e3 `$ o* @  V
30. 
    / Y( U' R, e1 x8 C  [3 i
31.   Crc = 0xFFFFFFFF;
    0 ~" [& U( N" L/ H- t! e2 |- H
32. 
    6 F. ^0 ?+ t! e) O1 f- J% h7 [
33.   for(j=0; j<6; j++)
    
34.   {
    
35.     Crc = Crc ^ (uint32_t)Mac[j];
    
36. 
    
37.     for(i=0; i<8; i++)
    / N$ O1 K$ ]" E, z7 H3 k
38.       if (Crc & 1)
    4 J. r  |% x9 i7 L& ]1 |+ `7 c
39.         Crc = (Crc >> 1) ^ 0xEDB88320; // Reversed 0x04C11DB7
    
40.       else
    ; g4 W$ H* l! Z: M6 ~8 t( t
41.         Crc = (Crc >> 1);
    " l. T4 Y6 {( n* J
42.   }
    
43. 
    
44.   return(Rev32(~Crc) >> 26); // Get High order 6-bit in reversed/inverted CRC
    
45. }
    
46. 
    8 p" X- Q" d% `  k0 w) [
47. uint32_t MacHashFast(const uint8_t *Mac) // <a href="mailto:sourcer32@gmail.com">sourcer32@gmail.com</a>
    ( U! p1 q7 q5 {" W; ?; R- _4 W
48. {
    9 F+ l! ]! T5 ?! }
49.   static const uint32_t Rev6Tbl[] = {
    2 N; G9 ?. @" S& ^* O, y' i
50.     0x00,0x20,0x10,0x30,0x08,0x28,0x18,0x38,
    % T* q1 J3 b; a- |- l2 v, J
51.     0x04,0x24,0x14,0x34,0x0C,0x2C,0x1C,0x3C,
    
52.     0x02,0x22,0x12,0x32,0x0A,0x2A,0x1A,0x3A,
    
53.     0x06,0x26,0x16,0x36,0x0E,0x2E,0x1E,0x3E,
    0 v; M& g! B  f' c. e, j/ p
54.     0x01,0x21,0x11,0x31,0x09,0x29,0x19,0x39,
    
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 };
    2 V* X$ e6 C" c! A: B# q
58. 
    5 ^# |1 O( h; V* @3 C& i
59.   static const uint32_t Crc32Tbl[] = {
    
60.     0x4DBDF21C, 0x500AE278, 0x76D3D2D4, 0x6B64C2B0,
    # Z0 K& \) [- S, o
61.     0x3B61B38C, 0x26D6A3E8, 0x000F9344, 0x1DB88320,
    
62.     0xA005713C, 0xBDB26158, 0x9B6B51F4, 0x86DC4190,
    2 u5 p* @4 f/ C9 ^, f/ G/ f3 }
63.     0xD6D930AC, 0xCB6E20C8, 0xEDB71064, 0xF0000000 };
    
64. 
    1 q% m& S( t( J7 v+ I
65.   int i;
    
66.   uint32_t Crc;
    
67. 
    
68.   Crc = 0;
    
69. 
    . C9 m# P3 |8 c* j: l
70.   for(i=0; i<6; i++)
    
71.   {
    
72.     Crc = Crc ^ (uint32_t)Mac<i>;
    ) A5 T/ ?( z" j
73. 
    % X4 E/ S- ~3 z: g) g
74. </i>   Crc = (Crc >> 4) ^ Crc32Tbl[Crc & 0x0F];  /* lower nibble */
    
75.     Crc = (Crc >> 4) ^ Crc32Tbl[Crc & 0x0F];  /* upper nibble */
    1 ?8 l6 ]" I5 u1 k2 M
76.   }
    
77. 
    
78.   return(Rev6Tbl[Crc & 0x3F]);
    $ k/ ]9 z) P5 k& n
79. }
    8 q4 p7 L+ P7 x) n4 [" U2 Q
80. 
    
81. int main(int argc, char **argv)
    
82. {
    
83.   static const uint8_t Test1[] = { 0x1F, 0x52, 0x41, 0x9C, 0xB6, 0xAF }; // 0x2C
    + ^, e* t9 o5 s, e- B
84.   static const uint8_t Test2[] = { 0xA0, 0x0A, 0x98, 0x00, 0x00, 0x45 }; // 0x07
    8 q' W5 @7 ]- p
85.   static const uint8_t Test3[] = { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x21 }; // 0x24
    0 D5 r! ~; ?( W0 T, {4 q
86. 
    / c) n6 R) a3 v
87.   printf("MacHash %02X\n", MacHash(Test1));
    6 W' w: F) @7 X  E( _
88.   printf("MacHash %02X\n", MacHash(Test2));
    
89.   printf("MacHash %02X\n", MacHash(Test3));
    
90. 
    1 U9 i/ C1 U* P) e/ q0 U
91.   printf("MacHashFast %02X\n", MacHashFast(Test1));
    
92.   printf("MacHashFast %02X\n", MacHashFast(Test2));
    # t! e6 `+ d# U& K
93.   printf("MacHashFast %02X\n", MacHashFast(Test3));
    
94. 
      W% b# f- H, ^
95.   return(1);
    2 h3 F" P1 z% ]
96. }

复制代码

; O* S# ~* t6 I0 p% ~9 P7 Y
回到手册
6 O$ q. J' L" @) F
) j5 D) {( R7 n- B( Y3 r# U

: n% |+ ^, s, a2 d* J

( U1 }: B, b- q
! H! T9 R$ P) h$ Z% r5 f6 i
' [8 [7 M0 }* K# \' G$ ~6 b* b& X上面的函数算出来一个数，假如是手册上的那个0x2c,二进制为101100B
, X+ L. {; P+ c! f' b6 O换句看得懂的人话···就是：
8 B! Y* H- y1 V8 _; o算出来的数先看第6位
是1的话说明用到的是HASH表高位寄存器
" L" g! i" p0 N  D* `# {9 |7 j+ a否则用到的是HASH表低位寄存器
) Q# ?# B6 K3 P8 S# |# G1 x6 }然后剩下的5位，转成十进制不是12嘛
; @+ o9 j1 U8 m* B如果你希望过滤这个MAC
. Q7 R$ G" _5 C' t: P8 Q6 a' E7 X3 z4 n那么你就把对应的HASH表高/低位寄存器的对应位置1，否则置0
0 A* H3 ^5 I$ G0 K+ w5 s2 S这里的0x2c就是要把
HASH表高位寄存器的第12位置1
就可以过滤这条MAC了
6 ]' `% P, z9 t然后把你希望的MAC地址都按照上面说的方法弄完

. m/ C: ]8 p0 q" g3 j: I4 @8 U回到这个函数稍微改一下
& {: l* ]( a1 i2 _. d% D+ m, ^' Y

1. uint8_t ETH_MAC_Setting(ETH_HandleTypeDef *heth)
   
2. {
   & C$ k1 x! J, @
3.     ETH_MACInitTypeDef macinit;
   . }9 u" w+ R# M/ U5 @2 Q- R) }% H" f
4.     /* Ethernet MAC default initialization **************************************/
   
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;
   + Q2 L* |; H( [$ C& K0 f+ b
10.     macinit.LoopbackMode = ETH_LOOPBACKMODE_DISABLE;
    6 B& V6 Q5 B+ r% Z; h. @9 P$ j. ~
11.     if (heth->Init.ChecksumMode == ETH_CHECKSUM_BY_HARDWARE)
    
12.     {
    
13.         macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_ENABLE;
    6 @- G; K. ]7 w/ t+ }; ]* `
14.     }
    1 I( x' {  q2 W3 t: B: V
15.     else
    6 G+ N7 j7 ?& q( {
16.     {
    ) n$ |- V; d4 E
17.         macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_DISABLE;
    - T1 d0 F. e" l
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;
    # K, V( S0 |9 a: x% d" G3 I+ y' W
23.     macinit.ReceiveAll = ETH_RECEIVEAll_DISABLE; ///不接收所有包
    
24.     macinit.SourceAddrFilter = ETH_SOURCEADDRFILTER_NORMAL_ENABLE; //源地址过滤
    / `& S7 e( u6 N' K
25.     macinit.PassControlFrames = ETH_PASSCONTROLFRAMES_BLOCKALL;
    ! o4 t0 e- V- C% v0 H4 h& F
26.     macinit.BroadcastFramesReception = ETH_BROADCASTFRAMESRECEPTION_DISABLE; //广播不接收
    3 c- c, ?2 A4 f7 N& F7 C. S
27.     macinit.DestinationAddrFilter = ETH_DESTINATIONADDRFILTER_NORMAL; //目的地址过滤
    
28.     macinit.PromiscuousMode = ETH_PROMISCUOUS_MODE_DISABLE; //混乱模式
    
29.     macinit.MulticastFramesFilter = ETH_MULTICASTFRAMESFILTER_PERFECTHASHTABLE; //！！多播HASH完美过滤
    ' Q* _( l1 z0 k. x
30.     macinit.UnicastFramesFilter = ETH_UNICASTFRAMESFILTER_PERFECTHASHTABLE; //！！单播HASH完美过滤
    
31.     macinit.HashTableHigh = 0x0; //！！填你最后算完的Hash表高位
    
32.     macinit.HashTableLow = 0x0; //！！填你最后算完的Hash表低位
    9 O2 P- t1 N- t3 B# }
33.     macinit.PauseTime = 0x0;
    
34.     macinit.ZeroQuantaPause = ETH_ZEROQUANTAPAUSE_DISABLE;
    + [' f4 a8 e' M0 r3 X8 l( v2 r) I1 V
35.     macinit.PauseLowThreshold = ETH_PAUSELOWTHRESHOLD_MINUS4;
    ) l/ r% W! k. w% e' M
36.     macinit.UnicastPauseFrameDetect = ETH_UNICASTPAUSEFRAMEDETECT_ENABLE;
    & ]( B: X1 o" Z2 ]5 f! }
37.     macinit.ReceiveFlowControl = ETH_RECEIVEFLOWCONTROL_DISABLE; //接收流控
    2 W. D% m& x! Q8 j) V
38.     macinit.TransmitFlowControl = ETH_TRANSMITFLOWCONTROL_DISABLE; //发送流控
    
39.     macinit.VLANTagComparison = ETH_VLANTAGCOMPARISON_16BIT;
    6 n( W; m4 [6 [. b  b
40.     macinit.VLANTagIdentifier = 0x0;
    
41. 
    
42.     return HAL_ETH_ConfigMAC(heth, &macinit);
    
43. }

复制代码

大概MAC层过滤就这些东西了
2 {' o2 L( V4 y如果有条件弄MAC层过滤真的强烈建议开启，可以大幅减轻协议栈的处理负担，板卡不会因为处理大量无用的数据而白白浪费处理性能。
) f! R6 o- y8 ?, O
/ u6 [. e+ z4 N
7 x8 _0 e* a6 n, I: e# n