前景描述
+ z4 N# g% M) `- [7 @9 B我司的以太网实现是LAN8720搭配片上MAC层做的，协议栈用LWIP

5 P) R, J. j: i6 |; M这种做法应该还是蛮常见的，反正不是LAN8720就是DP83864，再不然就是硬件协议栈的W5500了
: z3 d% j5 B$ m0 v7 J/ {9 b3 r
9 `! o6 o$ P- P- d2 ?( M" ^0 j5 y+ D想想还是有MAC层过滤比较好，随手翻了翻它的手册，W5500好像是没得MAC层过滤的
9 c) Y7 s$ a4 b2 [8 w  k; @
假如数据速率比较高，数据量大，而且外面还有乱七八糟无关的数据往板卡送，我也不知道用这个片子到底好不好
) s: W4 Y  k6 l" i7 [
LAN8720也不好改了，就继续用吧
' ]$ `* o# E$ c6 m6 K( t
好好在，发给板卡的数据的MAC还是有特征的，我只需要过滤发送方MAC地址的前3个字节，也就是特定的厂家那段
) ^" R: x( C9 f: H
2 J3 M6 m; Z2 r, CMAC地址的科普知识这里就不过多描述了，我们直奔主题
# k7 f6 Q# G1 S6 K( |  u/ W
- F: C: ^; y, s' w6 r怎么用STM32 F7的片上MAC做MAC层过滤
$ |$ j7 X6 U. a7 I/ A
& D' |* S7 h0 w# X写这个的目的，就是我搜了搜，没看见有人写这个MAC层过滤功能，具体代码怎么写才能用

知识科普-STM32的片上MAC
7 f6 y( ^) o  ZSTM32 F7的MAC层过滤方式有三种(说人话的直白解释，中文手册其实也翻译的不好)
7 ~! {1 c8 ^' N  m精确过滤(手册上叫单播目标/源地址过滤)
2 D( W$ I  u8 z# i0 D! A* Y粗糙过滤(手册上叫Hash表过滤)
# d/ ?, a6 w& ]特殊过滤(广播，组播过滤等等特殊的过滤)
我这里着重说第1种和第3种
. X6 \' }. X4 h) S
STM32 F7可以存4个MAC地址
其中MAC地址0是自己的MAC，其他三个可以用来做过滤

: c* I, C7 k4 f! {7 L网络数据包通过PHY进入STM32的MAC，MAC层是可以对目的地址/源地址检查并过滤掉没得用的数据的，默认的HAL库库函数HAL_ETH_Init中
有一个static的函数
static void ETH_MACDMAConfig(ETH_HandleTypeDef *heth, uint32_t err)
" u" G6 E: }9 A: j会帮你在初始化网络功能时初始化默认的MAC层功能:
5 K7 y5 q; A2 p1 ~8 T关闭源地址过滤
不接收所有数据
接收广播帧
打开目的地地址过滤
5 j, U9 }$ e9 w$ n1 y$ g单播数据精确过滤
4 J1 ?. ?5 {1 o' q组播数据精确过滤
7 l' I, c6 F1 ^( T6 V9 zHash表过滤关闭

其他的功能自行研究，我这里捡重要的说
4 P( w5 g8 B. a! `. Q: p0 w

1. static void ETH_MACDMAConfig(ETH_HandleTypeDef *heth, uint32_t err)
   
2. {
   1 Q6 O# O" T. f2 \4 \
3. ETH_MACInitTypeDef macinit;
   3 H9 l; E" v! C/ g  _: ~
4. ETH_DMAInitTypeDef dmainit;
   
5. uint32_t tmpreg = 0;
   - r# t- H$ p* x+ d0 h
6. 
   / R& B$ v. s; `/ a: n( T; `
7. if (err != ETH_SUCCESS) /* Auto-negotiation failed */
   & r+ O( d" \7 N, z' y% ?( z$ j5 m
8. {
   
9. /* Set Ethernet duplex mode to Full-duplex */
   / B3 n2 a! d. C3 W  }* }$ r
10. (heth->Init).DuplexMode = ETH_MODE_FULLDUPLEX;
    ' W; U# [9 L/ [7 V! n- |/ R
11. 
    # E+ q+ ^; ^2 j( K
12. /* Set Ethernet speed to 100M */
    
13. (heth->Init).Speed = ETH_SPEED_100M;
    & l- k4 K& |" Y" w
14. }
    
15. 
    
16. /* Ethernet MAC default initialization **************************************/
    
17. macinit.Watchdog = ETH_WATCHDOG_ENABLE;
    - {' r& Q) ?/ b, k" W* Y% J2 P
18. macinit.Jabber = ETH_JABBER_ENABLE;
    
19. macinit.InterFrameGap = ETH_INTERFRAMEGAP_96BIT;
    
20. macinit.CarrierSense = ETH_CARRIERSENCE_ENABLE;
    
21. macinit.ReceiveOwn = ETH_RECEIVEOWN_ENABLE;
    1 g. M; b4 s: T9 t, X
22. macinit.LoopbackMode = ETH_LOOPBACKMODE_DISABLE;
    , j; K2 }& F4 Y" C6 d
23. if(heth->Init.ChecksumMode == ETH_CHECKSUM_BY_HARDWARE)
    2 Q1 ~0 k6 C1 o" M5 M! n4 J6 K
24. {
    
25. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_ENABLE;
    , m! G3 k7 U: o
26. }
    
27. else
    2 T5 U& u3 w" r, o$ ~1 Z# {
28. {
    
29. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_DISABLE;
    
30. }
    8 @7 X; t4 A$ J
31. //这一段是MAC层过滤的设置，下面是DMA的，那个用默认的就可以
    # w& g4 Y. {2 l' F
32. macinit.RetryTransmission = ETH_RETRYTRANSMISSION_DISABLE;
    
33. macinit.AutomaticPadCRCStrip = ETH_AUTOMATICPADCRCSTRIP_DISABLE;
    
34. macinit.BackOffLimit = ETH_BACKOFFLIMIT_10;
    
35. macinit.DeferralCheck = ETH_DEFFERRALCHECK_DISABLE;
    
36. macinit.ReceiveAll = ETH_RECEIVEAll_DISABLE;
    . A4 A( m  K0 L( J, |
37. macinit.SourceAddrFilter = ETH_SOURCEADDRFILTER_DISABLE;
    
38. macinit.PassControlFrames = ETH_PASSCONTROLFRAMES_BLOCKALL;
    1 k0 k( x4 t$ h3 c& ?1 Z1 e
39. macinit.BroadcastFramesReception = ETH_BROADCASTFRAMESRECEPTION_ENABLE;
    . T% s& d9 u, G4 o0 M4 L& Y
40. macinit.DestinationAddrFilter = ETH_DESTINATIONADDRFILTER_NORMAL;
    0 ?. k6 S- \9 }, B5 E
41. macinit.PromiscuousMode = ETH_PROMISCUOUS_MODE_DISABLE;
    
42. macinit.MulticastFramesFilter = ETH_MULTICASTFRAMESFILTER_PERFECT;
    # t- I3 S' ?9 h: J+ N! j
43. macinit.UnicastFramesFilter = ETH_UNICASTFRAMESFILTER_PERFECT;
    ( \! x% [7 y* O9 I4 N
44. macinit.HashTableHigh = 0x0;
    
45. macinit.HashTableLow = 0x0;
    & h& a) O  Q2 R* y% x+ ?( ?
46. macinit.PauseTime = 0x0;
    
47. macinit.ZeroQuantaPause = ETH_ZEROQUANTAPAUSE_DISABLE;
    8 {6 [4 p1 b& Z0 j/ e  i$ a
48. macinit.PauseLowThreshold = ETH_PAUSELOWTHRESHOLD_MINUS4;
    & [& h2 N" B1 Z
49. macinit.UnicastPauseFrameDetect = ETH_UNICASTPAUSEFRAMEDETECT_DISABLE;
    4 _4 O. p- }+ ~8 K- ]
50. macinit.ReceiveFlowControl = ETH_RECEIVEFLOWCONTROL_DISABLE;
    $ W& K+ _$ t9 K3 {% f( y* {6 T
51. macinit.TransmitFlowControl = ETH_TRANSMITFLOWCONTROL_DISABLE;
    ) K9 ~1 x1 T8 k* e  }- N( @
52. macinit.VLANTagComparison = ETH_VLANTAGCOMPARISON_16BIT;
    + `) p- f4 S  q4 ?+ T, ?
53. macinit.VLANTagIdentifier = 0x0;
    
54. 
    
55. /*------------------------ ETHERNET MACCR Configuration --------------------*/
    
56. /* Get the ETHERNET MACCR value */
    1 W- W1 j7 G# s
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 */
    
61. /* Set the JD: bit according to ETH Jabber value */
    
62. /* Set the IFG bit according to ETH InterFrameGap value */
    
63. /* Set the DCRS bit according to ETH CarrierSense value */
    3 A$ a$ [% T7 c
64. /* Set the FES bit according to ETH Speed value */
    
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 */
    ! t0 m6 [3 i' v& {. L, N2 ?
68. /* Set the IPCO bit according to ETH ChecksumOffload value */
    8 p% W7 t& i; l. s% v
69. /* Set the DR bit according to ETH RetryTransmission value */
    
70. /* Set the ACS bit according to ETH AutomaticPadCRCStrip value */
    
71. /* Set the BL bit according to ETH BackOffLimit value */
    
72. /* Set the DC bit according to ETH DeferralCheck value */
    
73. tmpreg |= (uint32_t)(macinit.Watchdog |
    
74. macinit.Jabber |
    2 o% r+ |3 a8 J  |  `8 `5 y
75. macinit.InterFrameGap |
    
76. macinit.CarrierSense |
    / f& C4 {" ^8 K" T" q
77. (heth->Init).Speed |
    
78. macinit.ReceiveOwn |
      w1 g7 w2 |3 |) L8 Q3 F
79. macinit.LoopbackMode |
    
80. (heth->Init).DuplexMode |
    # `2 x: n: U) Q
81. macinit.ChecksumOffload |
    ' M$ @5 c0 y. P. P
82. macinit.RetryTransmission |
    / f/ U2 Y2 y0 q
83. macinit.AutomaticPadCRCStrip |
    
84. macinit.BackOffLimit |
    
85. macinit.DeferralCheck);
    
86. 
    4 \: k: z2 q2 O- j) t
87. /* Write to ETHERNET MACCR */
    # k3 Z) V- U2 Z' C+ F
88. (heth->Instance)->MACCR = (uint32_t)tmpreg;
    ; F) b0 p: R; q+ O6 z2 Y! m
89. 
    
90. /* Wait until the write operation will be taken into account:
    
91. at least four TX_CLK/RX_CLK clock cycles */
    , B: k+ R7 J% C% Q7 d8 m! Z6 o+ v
92. tmpreg = (heth->Instance)->MACCR;
    
93. HAL_Delay(ETH_REG_WRITE_DELAY);
    ) c( L0 t, F( C/ h+ U
94. (heth->Instance)->MACCR = tmpreg;
    0 U0 G) f0 G) \( V
95. 
    
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 */
    
99. /* Set the PCF bit according to ETH PassControlFrames value */
    5 D% a4 a% v' a0 A0 v+ k
100. /* Set the DBF bit according to ETH BroadcastFramesReception value */
     
101. /* Set the DAIF bit according to ETH DestinationAddrFilter value */
     ; J1 \5 W, w, Q# ?2 v
102. /* Set the PR bit according to ETH PromiscuousMode value */
     $ P$ f: k- e. T( R! t2 y* a) P
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 */
     5 o, ~' Q! l, c  G9 S6 l
106. (heth->Instance)->MACFFR = (uint32_t)(macinit.ReceiveAll |
     
107. macinit.SourceAddrFilter |
     5 o* N2 h. i. |
108. macinit.PassControlFrames |
     
109. macinit.BroadcastFramesReception |
       w% t7 N& g* D8 z" {6 w' X
110. macinit.DestinationAddrFilter |
     4 R  ?) d# T: ^3 ?5 ^+ q& M7 M
111. macinit.PromiscuousMode |
     
112. macinit.MulticastFramesFilter |
     5 w6 e; G. `' F. q, ^) Z5 H. I
113. macinit.UnicastFramesFilter);
     
114. 
     1 a$ B+ G: Z8 d9 f/ k
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);
     " `4 }. I& I7 \  a- D7 `0 X
119. (heth->Instance)->MACFFR = tmpreg;
     ) {! u0 ~6 }3 I+ W# R' g
120. 
     
121. /*--------------- ETHERNET MACHTHR and MACHTLR Configuration --------------*/
     
122. /* Write to ETHERNET MACHTHR */
     5 q4 g9 v' Y. \/ {& E1 U
123. (heth->Instance)->MACHTHR = (uint32_t)macinit.HashTableHigh;
     8 J% L) x; j- Y: |2 V0 S7 _0 q  |
124. 
     
125. /* Write to ETHERNET MACHTLR */
     * C% C0 b1 Y* h8 g- \  z2 M% R! S
126. (heth->Instance)->MACHTLR = (uint32_t)macinit.HashTableLow;
     
127. /*----------------------- ETHERNET MACFCR Configuration -------------------*/
     
128. 
     
129. /* Get the ETHERNET MACFCR value */
     7 b4 ]! q. \+ Q# ^* o9 d! P
130. tmpreg = (heth->Instance)->MACFCR;
     
131. /* Clear xx bits */
     ' J& h/ k* z) y" A* U# ^( n% t7 `' r
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 */
     2 m% L5 }5 Y' j2 @, [/ T1 i
136. /* Set the PLT bit according to ETH PauseLowThreshold value */
     
137. /* Set the UP bit according to ETH UnicastPauseFrameDetect value */
     1 E- f1 {2 p$ w# l$ x7 J. T
138. /* Set the RFE bit according to ETH ReceiveFlowControl value */
     : O/ M/ \& i$ @8 k8 i! a* _
139. /* Set the TFE bit according to ETH TransmitFlowControl value */
     ( a5 T# X( @. G
140. tmpreg |= (uint32_t)((macinit.PauseTime Instance)->MACFCR = (uint32_t)tmpreg;
     % q: P, C3 X5 l" ]+ |( H, h3 L8 A* N; ]
141. 
     
142. /* Wait until the write operation will be taken into account:
     
143. at least four TX_CLK/RX_CLK clock cycles */
     ! b2 |) W2 I2 v& ?/ t6 T9 s
144. tmpreg = (heth->Instance)->MACFCR;
     * R* ]: x/ T# H% }: n* S
145. HAL_Delay(ETH_REG_WRITE_DELAY);
     3 |* R: s* T. M+ N8 C: e# B
146. (heth->Instance)->MACFCR = tmpreg;
     4 K# Y6 E/ {) h: [. P
147. 
     
148. /*----------------------- ETHERNET MACVLANTR Configuration ----------------*/
     7 |5 o' I  K8 e+ z. p+ S
149. /* Set the ETV bit according to ETH VLANTagComparison value */
     + i& W9 R- O2 l- u! w# F  Y/ h8 G$ P
150. /* Set the VL bit according to ETH VLANTagIdentifier value */
     
151. (heth->Instance)->MACVLANTR = (uint32_t)(macinit.VLANTagComparison |
     , ]& c3 e; [: Y2 }5 D
152. macinit.VLANTagIdentifier);
     
153. 
     
154. /* Wait until the write operation will be taken into account:
     ; J& a  d6 P) Z
155.    at least four TX_CLK/RX_CLK clock cycles */
     
156. tmpreg = (heth->Instance)->MACVLANTR;
     
157. HAL_Delay(ETH_REG_WRITE_DELAY);
     
158. (heth->Instance)->MACVLANTR = tmpreg;
     ) k% B* U, q/ W
159. 
     
160. /* Ethernet DMA default initialization ************************************/
     & Y5 a( i: A& m
161. dmainit.DropTCPIPChecksumErrorFrame = ETH_DROPTCPIPCHECKSUMERRORFRAME_ENABLE;
     
162. dmainit.ReceiveStoreForward = ETH_RECEIVESTOREFORWARD_ENABLE;
     
163. dmainit.FlushReceivedFrame = ETH_FLUSHRECEIVEDFRAME_ENABLE;
     4 U; |1 {  i- O# d0 |/ k
164. dmainit.TransmitStoreForward = ETH_TRANSMITSTOREFORWARD_ENABLE;
     
165. dmainit.TransmitThresholdControl = ETH_TRANSMITTHRESHOLDCONTROL_64BYTES;
     % K" {' P" o$ c2 P/ X
166. dmainit.ForwardErrorFrames = ETH_FORWARDERRORFRAMES_DISABLE;
     : d& U: t2 u  Z; `* Q
167. dmainit.ForwardUndersizedGoodFrames = ETH_FORWARDUNDERSIZEDGOODFRAMES_DISABLE;
     
168. dmainit.ReceiveThresholdControl = ETH_RECEIVEDTHRESHOLDCONTROL_64BYTES;
     4 R: m5 ^3 q$ Q. Q
169. dmainit.SecondFrameOperate = ETH_SECONDFRAMEOPERARTE_ENABLE;
     1 Y5 ?6 c: u" B% Y3 j
170. dmainit.AddressAlignedBeats = ETH_ADDRESSALIGNEDBEATS_ENABLE;
     5 [5 t) l- W$ Z/ B& f
171. dmainit.FixedBurst = ETH_FIXEDBURST_ENABLE;
     4 |$ i* c1 T( F! k" H, d
172. dmainit.RxDMABurstLength = ETH_RXDMABURSTLENGTH_32BEAT;
     + P- y4 I+ s- M5 z1 W
173. dmainit.TxDMABurstLength = ETH_TXDMABURSTLENGTH_32BEAT;
     " g4 j, U. P; j2 F7 g. b
174. dmainit.EnhancedDescriptorFormat = ETH_DMAENHANCEDDESCRIPTOR_ENABLE;
     
175. dmainit.DescriptorSkipLength = 0x0;
     & j' N, \  n9 M' v( A
176. dmainit.DMAArbitration = ETH_DMAARBITRATION_ROUNDROBIN_RXTX_1_1;
     
177. 
     
178. /* Get the ETHERNET DMAOMR value */
     $ D4 ]7 T+ {# K* i: |
179. tmpreg = (heth->Instance)->DMAOMR;
     
180. /* Clear xx bits */
     
181. tmpreg &= ETH_DMAOMR_CLEAR_MASK;
     
182. 
     # }/ Z  E3 ]" c# h
183. /* Set the DT bit according to ETH DropTCPIPChecksumErrorFrame value */
     
184. /* Set the RSF bit according to ETH ReceiveStoreForward value */
     3 N; ]2 _5 q9 ?. ~8 U  N- T0 _
185. /* Set the DFF bit according to ETH FlushReceivedFrame value */
     5 o# h! I' E  s5 f9 u9 t
186. /* Set the TSF bit according to ETH TransmitStoreForward value */
     ' g, s6 l* ^( `9 G8 B) z  Z
187. /* Set the TTC bit according to ETH TransmitThresholdControl value */
     + V& n& _' w, b  Y4 i% F& X
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 */
     ; G* y; I; g0 T/ |6 c" X* ]- B
191. /* Set the OSF bit according to ETH SecondFrameOperate value */
     
192. tmpreg |= (uint32_t)(dmainit.DropTCPIPChecksumErrorFrame |
     
193.                      dmainit.ReceiveStoreForward |
     8 M4 l: C( x. E( @
194.                      dmainit.FlushReceivedFrame |
     # Y; P1 c# c4 \; K  i! x0 }- a
195.                      dmainit.TransmitStoreForward |
     0 ]8 X, r6 C/ ]5 k
196.                      dmainit.TransmitThresholdControl |
     
197.                      dmainit.ForwardErrorFrames |
     , b: M; \. ^0 P& w/ j
198.                      dmainit.ForwardUndersizedGoodFrames |
     * E; }% K; W6 E' m/ ^" K
199.                      dmainit.ReceiveThresholdControl |
     9 {' M/ w; t$ _9 C+ L* Z8 b. _; r
200.                      dmainit.SecondFrameOperate);
     
201. 
     
202. /* Write to ETHERNET DMAOMR */
     
203. (heth->Instance)->DMAOMR = (uint32_t)tmpreg;
     
204. 
     0 w; X% Y% ?1 c% i3 U/ u+ M
205. /* Wait until the write operation will be taken into account:
     
206.    at least four TX_CLK/RX_CLK clock cycles */
     3 J9 h' F$ C( q( o
207. tmpreg = (heth->Instance)->DMAOMR;
       e" _9 U3 F; j( I, u
208. HAL_Delay(ETH_REG_WRITE_DELAY);
     / k! i* x. r5 o+ u0 Q0 b) s
209. (heth->Instance)->DMAOMR = tmpreg;
     7 b4 H, z/ }, \2 k
210. 
     
211. /*----------------------- ETHERNET DMABMR Configuration ------------------*/
     - F7 q+ r. m7 v& U/ [5 j2 B2 \
212. /* Set the AAL bit according to ETH AddressAlignedBeats value */
     
213. /* Set the FB bit according to ETH FixedBurst value */
     
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 */
     
216. /* Set the Enhanced DMA descriptors bit according to ETH EnhancedDescriptorFormat value*/
     
217. /* Set the DSL bit according to ETH DesciptorSkipLength value */
     
218. /* Set the PR and DA bits according to ETH DMAArbitration value */
     
219. (heth->Instance)->DMABMR = (uint32_t)(dmainit.AddressAlignedBeats |
     
220.                                       dmainit.FixedBurst |
     ! p6 i$ i$ Y' X6 W2 x
221.                                       dmainit.RxDMABurstLength |    /* !! if 4xPBL is selected for Tx or Rx it is applied for the other */
     ; ]0 @: p! ?) y# W  ?' |2 s
222.                                       dmainit.TxDMABurstLength |
     
223.                                       dmainit.EnhancedDescriptorFormat |
     ( C! h+ u/ ~% U" X4 W* u7 x
224.                                       (dmainit.DescriptorSkipLength Instance)->DMABMR;
     
225. HAL_Delay(ETH_REG_WRITE_DELAY);
     
226. (heth->Instance)->DMABMR = tmpreg;
     
227. 
     - b; H( v7 x2 z9 g
228. if((heth->Init).RxMode == ETH_RXINTERRUPT_MODE)
     
229. {
     . {: [2 c, C. u- b0 U, {0 t3 M
230.    /* Enable the Ethernet Rx Interrupt */
     ' K! b7 ~' ]9 c8 L4 e
231.    __HAL_ETH_DMA_ENABLE_IT((heth), ETH_DMA_IT_NIS | ETH_DMA_IT_R);
     
232. }
     & X! U0 y) r; }  ^7 O& Z! @& |
233. 
     
234. /* Initialize MAC address in ethernet MAC */
     . }& V# j$ q. L' j: J
235. ETH_MACAddressConfig(heth, ETH_MAC_ADDRESS0, heth->Init.MACAddr);
     8 W) ^/ L* {. w  C" x
236. }

复制代码

这里我就要稍微吐槽一下HAL库了
6 d! ]+ u$ D9 ]1 N# wMAC层过滤的设置没有预留接口出来，有设置MAC地址的函数
( E) t" y/ H9 Z  M5 e' Z. Y
" g8 w/ Q; E7 E; ]  ostatic void ETH_MACAddressConfig(ETH_HandleTypeDef *heth, uint32_t MacAddr, uint8_t *Addr)

就不多做一个设置MAC层过滤的函数嘛，连后面用到的宏定义都有~~

- H( u# c/ s. h7 v. D/ H* X$ @木有办法，自己编一个初始化MAC层过滤的函数吧

5 m! l, {  {2 B$ S5 K其实也就是把上面这个ETH_MACDMAConfig函数分离成两个单独的设置函数，再编一个设置MAC层过滤的函数

开启MAC层过滤的初始化代码
3 ]4 f2 V8 J8 w" [" `$ {6 m

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;
   
7. macinit.InterFrameGap = ETH_INTERFRAMEGAP_96BIT;
   
8. macinit.CarrierSense = ETH_CARRIERSENCE_ENABLE;
   ' m- E2 j, e% k# X
9. macinit.ReceiveOwn = ETH_RECEIVEOWN_ENABLE;
   & m2 Q! K8 B2 V0 z' |9 j
10. macinit.LoopbackMode = ETH_LOOPBACKMODE_DISABLE;
    4 _+ d# ?# C* s& i& k% G: {! G% q( v
11. if (heth->Init.ChecksumMode == ETH_CHECKSUM_BY_HARDWARE)
    $ J: r& o+ i6 I& P. Q' P
12. {
    0 Q; X) L0 ^  I1 {3 X* s5 {
13. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_ENABLE;
    
14. }
    
15. else
    2 T# {2 g* Y9 G( c
16. {
    . S) ?6 F6 h4 u: A
17. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_DISABLE;
    
18. }
    , r, _+ a+ _9 X0 _, @7 C/ ?; Z
19. macinit.RetryTransmission = ETH_RETRYTRANSMISSION_ENABLE;          //使能重传
    % }& K: e! Y2 `: @5 A" x0 W8 t9 t
20. macinit.AutomaticPadCRCStrip = ETH_AUTOMATICPADCRCSTRIP_ENABLE;          //使能自动去除
    * W0 B* F& x# H
21. macinit.BackOffLimit = ETH_BACKOFFLIMIT_10;
    4 Y. n# ]) r2 F' i8 ?+ w- Q; B
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; //多播过滤
    ) o, S  t6 i8 W
30. macinit.UnicastFramesFilter = ETH_UNICASTFRAMESFILTER_PERFECT; //单播过滤
    4 A; F/ q1 N; N8 N; f
31. macinit.HashTableHigh = 0x0; //Hash表高位
    ; O! {# r) b( J: ^
32. macinit.HashTableLow = 0x0; //Hash表低位
    9 F3 v+ M/ v# ?' A. C
33. macinit.PauseTime = 0x0;
    
34. macinit.ZeroQuantaPause = ETH_ZEROQUANTAPAUSE_DISABLE;
    
35. macinit.PauseLowThreshold = ETH_PAUSELOWTHRESHOLD_MINUS4;
    
36. macinit.UnicastPauseFrameDetect = ETH_UNICASTPAUSEFRAMEDETECT_ENABLE;
    : _" e8 g+ f" Y; ]. z
37. macinit.ReceiveFlowControl = ETH_RECEIVEFLOWCONTROL_DISABLE; //接收流控
    1 z7 A" `% y6 j& H. _" f
38. macinit.TransmitFlowControl = ETH_TRANSMITFLOWCONTROL_DISABLE; //发送流控
    ; L4 x3 c$ U& R* _% P1 d/ z9 q
39. macinit.VLANTagComparison = ETH_VLANTAGCOMPARISON_16BIT;
    
40. macinit.VLANTagIdentifier = 0x0;
    
41. 
    
42. return HAL_ETH_ConfigMAC(heth, &macinit);
    
43. }

复制代码

6 i/ J% X6 t. u8 m/ ]默认的MAC层 DMA初始化函数
9 S( v6 }/ k5 O8 n

1. uint8_t ETH_DMA_Setting(ETH_HandleTypeDef *heth)
   
2. {
   
3. ETH_DMAInitTypeDef dmainit;
   + M5 g+ Y( ^5 Q
4. /* Ethernet DMA default initialization ************************************/
   5 G* |; O9 Y5 |9 z6 P- _
5. dmainit.DropTCPIPChecksumErrorFrame = ETH_DROPTCPIPCHECKSUMERRORFRAME_ENABLE;
   
6. dmainit.ReceiveStoreForward = ETH_RECEIVESTOREFORWARD_ENABLE;
   
7. dmainit.FlushReceivedFrame = ETH_FLUSHRECEIVEDFRAME_ENABLE;
   
8. dmainit.TransmitStoreForward = ETH_TRANSMITSTOREFORWARD_ENABLE;
   . r4 R1 `% A/ `7 x* y
9. dmainit.TransmitThresholdControl = ETH_TRANSMITTHRESHOLDCONTROL_64BYTES;
   
10. dmainit.ForwardErrorFrames = ETH_FORWARDERRORFRAMES_DISABLE;
    
11. dmainit.ForwardUndersizedGoodFrames = ETH_FORWARDUNDERSIZEDGOODFRAMES_DISABLE;
    ! K2 q4 v. ]/ w+ ?- F- n8 m1 O
12. dmainit.ReceiveThresholdControl = ETH_RECEIVEDTHRESHOLDCONTROL_64BYTES;
    8 a3 K8 ~9 b+ O5 L8 w" U9 z
13. dmainit.SecondFrameOperate = ETH_SECONDFRAMEOPERARTE_ENABLE;
    
14. dmainit.AddressAlignedBeats = ETH_ADDRESSALIGNEDBEATS_ENABLE;
    
15. dmainit.FixedBurst = ETH_FIXEDBURST_ENABLE;
    
16. dmainit.RxDMABurstLength = ETH_RXDMABURSTLENGTH_32BEAT;
    
17. dmainit.TxDMABurstLength = ETH_TXDMABURSTLENGTH_32BEAT;
    & S$ ?' p: y4 C) T4 |
18. dmainit.EnhancedDescriptorFormat = ETH_DMAENHANCEDDESCRIPTOR_ENABLE;
    & R/ y' a; M. }1 u
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)
    ) i. ~' p! b- s( Y' ~& t3 V/ e& c
23. {
    ( u" r, p0 e$ x1 Q# \% h
24. /* Enable the Ethernet Rx Interrupt */
    
25. __HAL_ETH_DMA_ENABLE_IT((heth), ETH_DMA_IT_NIS | ETH_DMA_IT_R);
    7 E1 G; B+ O, R% D
26. }
      g: r7 [7 `; W* _- r
27. return res;
    
28. }

复制代码

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

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

复制代码

1 o7 H7 Q, [* ?& Z1 j然后到最最重要的MAC层过滤设置
$ X) S" Z; C  |( y* y以MAC1为例
; @' A# ~9 S3 I. H: L- Z

1 ?; q% p1 ^: u2 \  V$ j# C

! T3 B5 j7 Y8 p# |5 `0 q8 c3 L
注意看红框的描述
2 Q5 Y9 n7 N8 ?/ p+ S' K功能很好用，可以过滤源地址/目的地址，还可以做掩码功能
: Z. t0 N: b$ `' `; F: O- N设置MAC层过滤的代码
% c  I& X( f# Y5 W5 }: Q2 |# C, h

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);
   
5.     //设置UDP-A的对方MAC地址
   
6.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS1,para->UDP_A_MAC);
   ; ~( x& @0 ~4 N2 ^* M8 J
7.     (heth->Instance)->MACA1HR|=0xC0000000;//需要完全匹配UDP-A的对方MAC才接收
   # P  U: H% y, Q  j4 j
8.     //设置UDP-B的对方MAC地址
   , M6 d+ {6 O" j8 `, K0 d9 x
9.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS2,para->UDP_B_MAC);
   
10.     (heth->Instance)->MACA2HR|=0xC0000000;//需要完全匹配UDP-A的对方MAC才接收
    / g, B0 ~$ W0 n
11. }

复制代码

8 Q& E' i. V& ]" g' c- j我这里是希望为我的两个UDP精确过滤接收到的源地址
所以AE位设置为1，SA设置为1，MBC全部为0(MAC地址全部检查)

' `' z# A  x: F. D+ C2 a7 |- D假如我希望过滤MAC中特定的厂家字段
: F  T; E* [3 {7 Q/ \6 W例如某个MAC地址
01-02-03-04-05-06
( l) i- g0 C" d) G4 ?  T其中01-02-03就是厂家字段
0 ~$ d/ b1 n$ s* E% O, G
那么代码要这样修改（MBC的第29位，28位，27位置1）
9 D! E" G7 w. x; X) Q$ k  a这样MAC层就不会检查MAC地址里后3个字节(04-05-06)
6 a! `1 H! r  D: G6 d# _' G" [( X; W0 Q但是会检查前3个字节，也就是厂家字段
' d) L1 c4 m' q这里需要注意MAC地址的字节序

1. static void ETH_MAC_Filter_Setting(ETH_HandleTypeDef *heth,ST_ETH_PAR * para)
   
2. {
   4 \' D- R, o2 f+ w5 L, b; z1 Y
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|=0xF8000000;//需要匹配厂家字段
   3 y" E; v2 y1 u# O/ }
8.     //设置UDP-B的对方MAC地址
   ; ?/ S% g2 d1 N* K: X
9.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS2,para->UDP_B_MAC);
   4 q: A' m4 {  p
10.     (heth->Instance)->MACA2HR|=0xF8000000;//需要匹配厂家字段
    * s9 g/ s  Y' e( L+ D
11. }

复制代码

, D. E9 o+ L  m然后这些函数的调用顺序按:
1. HAL_ETH_Init
' c- r5 h& K, g2 X2. ETH_MAC_Setting
0 {4 C7 v5 W* l! p+ r* s3 ?3. ETH_DMA_Setting
9 W" T7 H  e8 U. U' D# R' N' ?! k4. ETH_MAC_Filter_Setting
" U+ h3 _0 V& W: N6 w
用你希望过滤的MAC传递到一个Hash计算函数里，得到一个值，通过这个值产生“映射”关系来过滤MAC地址，所以这个并不是精确的，因为可能会重复~~

+ x6 K& l$ @9 \' a; R" l5 bHASH函数
函数

1. / STM32 MACHASH - Copyright (C) 2014-2018 Clive Turvey (<a href="mailto:sourcer32@gmail.com">sourcer32@gmail.com</a>)
   ; q, C, d. u6 q: ~, n! W% C
2. //  All Rights Reserved
   " j! m7 C: x; t7 l7 h
3. 
   ( s% o3 L1 O$ Q& _
4. #include <windows.h>
   # h2 P- `1 W( @% ~; Z' P$ N
5. 
   
6. #include <stdio.h>
   
7. #include <stdlib.h>
   
8. 
   
9. typedef unsigned char uint8_t;
   4 q  V; g9 U% v& }. R
10. typedef unsigned long uint32_t;
    2 H1 ?4 G; Y; y7 e& O' h
11. 
    
12. uint32_t Rev32(uint32_t x)
    
13. {
    - m" ?  c' B3 @, i: O
14.   uint32_t y;
    
15.   int i;
    
16. 
    " M" D2 T5 {4 `) k# i/ r5 ~4 B
17.   y = 0;
    ; F7 i; }! c$ G* p3 T$ w$ V/ A8 s
18. 
    ( d3 D, c3 `9 {
19.   for(i=0; i<32; i++)
    0 }  B9 X' n6 y! x5 s  G
20.     if (x & (1 << i))
    ( l$ M. z& @0 v+ ]+ E
21.       y |= 1 << (31 - i);
    
22. 
    
23.   return(y);
    9 O$ Q! W: v8 R- @$ ?1 Q
24. }
    
25. 
    0 v; j! Y" `9 G  P
26. uint32_t MacHash(const uint8_t *Mac) // <a href="mailto:sourcer32@gmail.com">sourcer32@gmail.com</a>
    7 |# ~2 k- s5 J- ?- O# A
27. {
      g8 C! J6 t" \. E- Y7 G" V
28.   int i, j;
    + q; {* r9 z3 J% G/ p
29.   uint32_t Crc;
    ! [6 Y4 A6 q6 o/ V: o7 w
30. 
    " j! S. g9 H0 z4 b
31.   Crc = 0xFFFFFFFF;
    2 C0 ?: a6 c! L! j$ e
32. 
    9 u2 H2 i/ r- b" C
33.   for(j=0; j<6; j++)
    $ `' |# i9 W3 Y* L7 ?( z
34.   {
    - w# H2 d' {- U6 ~7 y1 d8 Y, N
35.     Crc = Crc ^ (uint32_t)Mac[j];
    0 u: C9 F* b+ y8 \
36. 
    
37.     for(i=0; i<8; i++)
    
38.       if (Crc & 1)
    ) I* b7 `; a' y+ L' K
39.         Crc = (Crc >> 1) ^ 0xEDB88320; // Reversed 0x04C11DB7
    
40.       else
    * D) U  {7 f4 |1 K3 n0 T
41.         Crc = (Crc >> 1);
    
42.   }
    
43. 
    1 T. q" M: b0 Y; s% L, I5 o
44.   return(Rev32(~Crc) >> 26); // Get High order 6-bit in reversed/inverted CRC
    * ^  O) P: ^+ y" y2 |$ }
45. }
    
46. 
    
47. uint32_t MacHashFast(const uint8_t *Mac) // <a href="mailto:sourcer32@gmail.com">sourcer32@gmail.com</a>
    9 ]: {$ n$ B/ h2 m3 |2 Q/ L$ K. L
48. {
    - t5 m4 m0 y' w7 ^' p
49.   static const uint32_t Rev6Tbl[] = {
    + R9 W3 q  O$ q% Q  |$ {. ?
50.     0x00,0x20,0x10,0x30,0x08,0x28,0x18,0x38,
    
51.     0x04,0x24,0x14,0x34,0x0C,0x2C,0x1C,0x3C,
    , R/ g# U# T3 I% u, G7 Q+ h$ v5 f7 B
52.     0x02,0x22,0x12,0x32,0x0A,0x2A,0x1A,0x3A,
    - a: \, g+ c. I
53.     0x06,0x26,0x16,0x36,0x0E,0x2E,0x1E,0x3E,
    9 B0 @" Q1 Y3 T7 O* I: ]& U$ O
54.     0x01,0x21,0x11,0x31,0x09,0x29,0x19,0x39,
    4 D' _1 O0 Q& E1 e; Z
55.     0x05,0x25,0x15,0x35,0x0D,0x2D,0x1D,0x3D,
    
56.     0x03,0x23,0x13,0x33,0x0B,0x2B,0x1B,0x3B,
    $ j' E( w' W/ [
57.     0x07,0x27,0x17,0x37,0x0F,0x2F,0x1F,0x3F };
    
58. 
    
59.   static const uint32_t Crc32Tbl[] = {
    
60.     0x4DBDF21C, 0x500AE278, 0x76D3D2D4, 0x6B64C2B0,
    
61.     0x3B61B38C, 0x26D6A3E8, 0x000F9344, 0x1DB88320,
    
62.     0xA005713C, 0xBDB26158, 0x9B6B51F4, 0x86DC4190,
    4 R3 G; z) a1 D  U0 j  N. g
63.     0xD6D930AC, 0xCB6E20C8, 0xEDB71064, 0xF0000000 };
    
64. 
    
65.   int i;
    
66.   uint32_t Crc;
    % _  e" N' C3 r4 M
67. 
    
68.   Crc = 0;
    ! H/ w7 O, u) k' w3 ]
69. 
    
70.   for(i=0; i<6; i++)
    
71.   {
    % \) ~$ c/ x( G
72.     Crc = Crc ^ (uint32_t)Mac<i>;
    % B: y. a. {) c. b; E
73. 
    9 b4 O! ^% |! T! X
74. </i>   Crc = (Crc >> 4) ^ Crc32Tbl[Crc & 0x0F];  /* lower nibble */
    ; g1 I2 q  ?. I: w5 l2 f" ~" ^  x
75.     Crc = (Crc >> 4) ^ Crc32Tbl[Crc & 0x0F];  /* upper nibble */
    
76.   }
    
77. 
    
78.   return(Rev6Tbl[Crc & 0x3F]);
    0 C, ]' A$ a8 b& h
79. }
    
80. 
    
81. int main(int argc, char **argv)
    + ?6 c% y9 c  e
82. {
    
83.   static const uint8_t Test1[] = { 0x1F, 0x52, 0x41, 0x9C, 0xB6, 0xAF }; // 0x2C
    ; y8 G. F  O7 P* \" D5 \& }1 q5 C4 S
84.   static const uint8_t Test2[] = { 0xA0, 0x0A, 0x98, 0x00, 0x00, 0x45 }; // 0x07
    8 s3 ~. I' ?4 Z
85.   static const uint8_t Test3[] = { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x21 }; // 0x24
    4 W2 Q4 W# l4 T, |7 s1 g% H" b2 _' Z
86. 
    
87.   printf("MacHash %02X\n", MacHash(Test1));
    7 P- _# j5 _5 B1 l4 W2 S6 P  e
88.   printf("MacHash %02X\n", MacHash(Test2));
    & ^6 Q# c" b7 b5 I' k
89.   printf("MacHash %02X\n", MacHash(Test3));
    $ g* e5 l  t% U0 G5 A& T
90. 
    
91.   printf("MacHashFast %02X\n", MacHashFast(Test1));
    - G* K* m- q" a% X7 v, r  v
92.   printf("MacHashFast %02X\n", MacHashFast(Test2));
    1 h! {, t; X" L
93.   printf("MacHashFast %02X\n", MacHashFast(Test3));
    5 P0 x% x" s7 k* z  t$ v0 o/ R! l
94. 
    
95.   return(1);
    
96. }

复制代码

回到手册

" N( s6 U1 y2 a' d

' E4 C) l0 Y" m6 l2 b2 V

" o" {) D5 e, A8 f" E7 @! }
8 ?* V8 c5 o0 Y$ H/ u
% O9 h; g$ T! I* [! |8 |上面的函数算出来一个数，假如是手册上的那个0x2c,二进制为101100B
4 H; `$ |- j, \/ w" e换句看得懂的人话···就是：
算出来的数先看第6位
是1的话说明用到的是HASH表高位寄存器
否则用到的是HASH表低位寄存器
然后剩下的5位，转成十进制不是12嘛
如果你希望过滤这个MAC
那么你就把对应的HASH表高/低位寄存器的对应位置1，否则置0
这里的0x2c就是要把
HASH表高位寄存器的第12位置1
; v9 w9 X2 c3 U就可以过滤这条MAC了
  M, I2 h5 m" r4 H, l' x+ I5 ]然后把你希望的MAC地址都按照上面说的方法弄完

: W4 z. V# H5 z回到这个函数稍微改一下

1. uint8_t ETH_MAC_Setting(ETH_HandleTypeDef *heth)
   2 M$ y) x4 P" s4 S, u& C1 I, u
2. {
   
3.     ETH_MACInitTypeDef macinit;
   
4.     /* Ethernet MAC default initialization **************************************/
   
5.     macinit.Watchdog = ETH_WATCHDOG_ENABLE;
   6 M# u+ f/ O1 k3 R4 U$ |
6.     macinit.Jabber = ETH_JABBER_ENABLE;
   % X2 d( b7 n  d6 r0 Q( `
7.     macinit.InterFrameGap = ETH_INTERFRAMEGAP_96BIT;
   
8.     macinit.CarrierSense = ETH_CARRIERSENCE_ENABLE;
   ! x% r  B7 V; T* ?
9.     macinit.ReceiveOwn = ETH_RECEIVEOWN_ENABLE;
   
10.     macinit.LoopbackMode = ETH_LOOPBACKMODE_DISABLE;
    4 V! A% d, C2 {$ Z( ^$ J: ^
11.     if (heth->Init.ChecksumMode == ETH_CHECKSUM_BY_HARDWARE)
    , w5 V7 n# F' g& t. B/ o0 {& G
12.     {
    
13.         macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_ENABLE;
    ! Y/ l5 y* ^2 C8 }! d7 U
14.     }
    
15.     else
    9 h7 t2 B* u. L2 Q( N. M8 h* R
16.     {
    
17.         macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_DISABLE;
    
18.     }
    
19.     macinit.RetryTransmission = ETH_RETRYTRANSMISSION_ENABLE;          //使能重传
    / `# i5 u% P9 U  t) u5 Q1 ?; @
20.     macinit.AutomaticPadCRCStrip = ETH_AUTOMATICPADCRCSTRIP_ENABLE;          //使能自动去除
    $ N( k5 d' ~: o
21.     macinit.BackOffLimit = ETH_BACKOFFLIMIT_10;
    4 m1 H7 r4 ]6 q  b& R3 E% Y
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; //广播不接收
    # _; j& W. ?, w1 a/ C4 V) \# B9 N9 T
27.     macinit.DestinationAddrFilter = ETH_DESTINATIONADDRFILTER_NORMAL; //目的地址过滤
    
28.     macinit.PromiscuousMode = ETH_PROMISCUOUS_MODE_DISABLE; //混乱模式
    
29.     macinit.MulticastFramesFilter = ETH_MULTICASTFRAMESFILTER_PERFECTHASHTABLE; //！！多播HASH完美过滤
    ! W- \( q! A' W- t2 s
30.     macinit.UnicastFramesFilter = ETH_UNICASTFRAMESFILTER_PERFECTHASHTABLE; //！！单播HASH完美过滤
    
31.     macinit.HashTableHigh = 0x0; //！！填你最后算完的Hash表高位
    , x8 k' O* d4 u; e
32.     macinit.HashTableLow = 0x0; //！！填你最后算完的Hash表低位
    ! A9 k/ l. E; h2 x' g6 X
33.     macinit.PauseTime = 0x0;
    # \- l0 x6 m$ f* h
34.     macinit.ZeroQuantaPause = ETH_ZEROQUANTAPAUSE_DISABLE;
    
35.     macinit.PauseLowThreshold = ETH_PAUSELOWTHRESHOLD_MINUS4;
    " x2 y2 |2 q9 c( W+ y
36.     macinit.UnicastPauseFrameDetect = ETH_UNICASTPAUSEFRAMEDETECT_ENABLE;
    
37.     macinit.ReceiveFlowControl = ETH_RECEIVEFLOWCONTROL_DISABLE; //接收流控
    8 i0 `9 n$ @. `0 s) g& e; H
38.     macinit.TransmitFlowControl = ETH_TRANSMITFLOWCONTROL_DISABLE; //发送流控
    
39.     macinit.VLANTagComparison = ETH_VLANTAGCOMPARISON_16BIT;
    
40.     macinit.VLANTagIdentifier = 0x0;
    
41. 
    
42.     return HAL_ETH_ConfigMAC(heth, &macinit);
    
43. }

复制代码

" y) `3 u8 A% [: y& C大概MAC层过滤就这些东西了
: U4 W0 l  S5 |: N如果有条件弄MAC层过滤真的强烈建议开启，可以大幅减轻协议栈的处理负担，板卡不会因为处理大量无用的数据而白白浪费处理性能。



! L& _. b2 g; l3 {6 N0 V# O