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

9 b2 l, T- ]4 E4 ~; N- t8 x这种做法应该还是蛮常见的，反正不是LAN8720就是DP83864，再不然就是硬件协议栈的W5500了

想想还是有MAC层过滤比较好，随手翻了翻它的手册，W5500好像是没得MAC层过滤的
! f6 U" X# o; T4 q7 Y  ]; |
, z/ l% P: |* i假如数据速率比较高，数据量大，而且外面还有乱七八糟无关的数据往板卡送，我也不知道用这个片子到底好不好
3 ]: Q5 k" r4 m; K
LAN8720也不好改了，就继续用吧

0 }% z7 D! m3 F8 {" n好好在，发给板卡的数据的MAC还是有特征的，我只需要过滤发送方MAC地址的前3个字节，也就是特定的厂家那段
# R6 Y# b+ S/ C1 p, P. ?: d# K
MAC地址的科普知识这里就不过多描述了，我们直奔主题

怎么用STM32 F7的片上MAC做MAC层过滤
0 s8 r/ _4 R- @( f* r- _
5 E" j" Q1 K% u; w$ E3 _写这个的目的，就是我搜了搜，没看见有人写这个MAC层过滤功能，具体代码怎么写才能用

知识科普-STM32的片上MAC
% R" C- w6 g- y7 i! \STM32 F7的MAC层过滤方式有三种(说人话的直白解释，中文手册其实也翻译的不好)
精确过滤(手册上叫单播目标/源地址过滤)
6 K" y1 ?8 L$ ^/ @$ l粗糙过滤(手册上叫Hash表过滤)
, A( ~# G& Z% E6 P3 q特殊过滤(广播，组播过滤等等特殊的过滤)
我这里着重说第1种和第3种

, B4 T% a8 U( H6 L- |- J7 `# }STM32 F7可以存4个MAC地址
9 h3 j- |% T5 Y0 w! @9 J, B: ?# w/ h! h其中MAC地址0是自己的MAC，其他三个可以用来做过滤
2 r! m" f2 M7 c; {6 Z4 X( D+ u
- b( f( @3 Z% H5 a0 ]$ F网络数据包通过PHY进入STM32的MAC，MAC层是可以对目的地址/源地址检查并过滤掉没得用的数据的，默认的HAL库库函数HAL_ETH_Init中
有一个static的函数
static void ETH_MACDMAConfig(ETH_HandleTypeDef *heth, uint32_t err)
会帮你在初始化网络功能时初始化默认的MAC层功能:
关闭源地址过滤
, C. d/ }! |: X+ u) G2 m不接收所有数据
  T& l+ B0 m2 ~$ R) k, a7 v接收广播帧
打开目的地地址过滤
  U0 a) i" A; X单播数据精确过滤
, A" t% L4 {! G  x组播数据精确过滤
, ]2 X+ ^/ c5 X4 ^# X' r6 QHash表过滤关闭
4 q) Z' o. j2 @3 r9 W! ?
8 t0 x+ I' g& z: h/ ]( u, L其他的功能自行研究，我这里捡重要的说
. _3 p) O$ v- T- y9 {  ~! k3 q

1. static void ETH_MACDMAConfig(ETH_HandleTypeDef *heth, uint32_t err)
   
2. {
   2 d" F* I) z- `' U2 `# M$ {, g" Y
3. ETH_MACInitTypeDef macinit;
   
4. ETH_DMAInitTypeDef dmainit;
   % K, Z% ~' N% B
5. uint32_t tmpreg = 0;
     u# u# }: ?4 D0 r' _. Y# I
6. 
   
7. if (err != ETH_SUCCESS) /* Auto-negotiation failed */
   ! [( V& H, ~" R7 X5 W
8. {
   
9. /* Set Ethernet duplex mode to Full-duplex */
   
10. (heth->Init).DuplexMode = ETH_MODE_FULLDUPLEX;
    5 O, N& G+ z8 m# `
11. 
    % N! k% O1 f4 a2 ]
12. /* Set Ethernet speed to 100M */
    : k6 e2 m7 P/ D, e7 `! W' u
13. (heth->Init).Speed = ETH_SPEED_100M;
    
14. }
    8 {4 S1 q1 [* f, m
15. 
    
16. /* Ethernet MAC default initialization **************************************/
    
17. macinit.Watchdog = ETH_WATCHDOG_ENABLE;
    / h* `# f& `0 V# [& ^5 q
18. macinit.Jabber = ETH_JABBER_ENABLE;
    
19. macinit.InterFrameGap = ETH_INTERFRAMEGAP_96BIT;
    
20. macinit.CarrierSense = ETH_CARRIERSENCE_ENABLE;
    
21. macinit.ReceiveOwn = ETH_RECEIVEOWN_ENABLE;
    
22. macinit.LoopbackMode = ETH_LOOPBACKMODE_DISABLE;
    
23. if(heth->Init.ChecksumMode == ETH_CHECKSUM_BY_HARDWARE)
    2 P( K' l1 Q  P+ I# N
24. {
    7 a- j" D; |7 a4 t  v
25. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_ENABLE;
    - ~) i) ?) I9 z. M6 f# z
26. }
    
27. else
    
28. {
    
29. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_DISABLE;
    
30. }
    / B, v3 S. K0 A+ a/ b! q" y( t+ \5 |
31. //这一段是MAC层过滤的设置，下面是DMA的，那个用默认的就可以
    
32. macinit.RetryTransmission = ETH_RETRYTRANSMISSION_DISABLE;
    
33. macinit.AutomaticPadCRCStrip = ETH_AUTOMATICPADCRCSTRIP_DISABLE;
    7 A0 p4 h, \2 ?' E! v1 P
34. macinit.BackOffLimit = ETH_BACKOFFLIMIT_10;
    
35. macinit.DeferralCheck = ETH_DEFFERRALCHECK_DISABLE;
    
36. macinit.ReceiveAll = ETH_RECEIVEAll_DISABLE;
    
37. macinit.SourceAddrFilter = ETH_SOURCEADDRFILTER_DISABLE;
    
38. macinit.PassControlFrames = ETH_PASSCONTROLFRAMES_BLOCKALL;
    & k" P( C; q5 K. ~! V/ g
39. macinit.BroadcastFramesReception = ETH_BROADCASTFRAMESRECEPTION_ENABLE;
    8 t# O# q1 Q/ l* I; j& H( B
40. macinit.DestinationAddrFilter = ETH_DESTINATIONADDRFILTER_NORMAL;
    
41. macinit.PromiscuousMode = ETH_PROMISCUOUS_MODE_DISABLE;
    ) A  ]& ~( m! y' M. T
42. macinit.MulticastFramesFilter = ETH_MULTICASTFRAMESFILTER_PERFECT;
    
43. macinit.UnicastFramesFilter = ETH_UNICASTFRAMESFILTER_PERFECT;
    2 Y" O; W: A$ @) u
44. macinit.HashTableHigh = 0x0;
    2 q( n, O/ W* d% Y+ v  }
45. macinit.HashTableLow = 0x0;
    ; x4 r, ]: M" P
46. macinit.PauseTime = 0x0;
    
47. macinit.ZeroQuantaPause = ETH_ZEROQUANTAPAUSE_DISABLE;
    3 d; r  Q8 L& w. I1 V' B
48. macinit.PauseLowThreshold = ETH_PAUSELOWTHRESHOLD_MINUS4;
    3 ]* c2 Y/ p, ~2 v. \. _
49. macinit.UnicastPauseFrameDetect = ETH_UNICASTPAUSEFRAMEDETECT_DISABLE;
    9 l+ N( T6 r! u3 e# J2 ^3 H
50. macinit.ReceiveFlowControl = ETH_RECEIVEFLOWCONTROL_DISABLE;
    % Z6 h! a8 F6 H- X3 l9 A- }
51. macinit.TransmitFlowControl = ETH_TRANSMITFLOWCONTROL_DISABLE;
    
52. macinit.VLANTagComparison = ETH_VLANTAGCOMPARISON_16BIT;
    % U- C% N5 S1 v9 D' j- D0 M" ^$ X; b9 q
53. macinit.VLANTagIdentifier = 0x0;
    % Z6 E) M% p' P) o6 k8 G
54. 
    9 a! `  S  O9 j6 D6 J3 Z
55. /*------------------------ ETHERNET MACCR Configuration --------------------*/
    
56. /* Get the ETHERNET MACCR value */
    
57. tmpreg = (heth->Instance)->MACCR;
    
58. /* Clear WD, PCE, PS, TE and RE bits */
    0 H4 l8 d' @/ c0 X4 i' P
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 */
    . q1 P& d6 ?. S8 [4 l& v/ t' Y" ~0 H
62. /* Set the IFG bit according to ETH InterFrameGap value */
    & y+ }) V) [/ g- j
63. /* Set the DCRS bit according to ETH CarrierSense value */
    9 n6 s+ y# |& s+ [8 H9 N! ?" u9 M
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 */
    
68. /* Set the IPCO bit according to ETH ChecksumOffload value */
    & T5 B+ K" x& q0 p2 j4 U
69. /* Set the DR bit according to ETH RetryTransmission value */
    $ i7 n2 v6 j2 B
70. /* Set the ACS bit according to ETH AutomaticPadCRCStrip value */
      j7 W* F% R8 {: r0 w
71. /* Set the BL bit according to ETH BackOffLimit value */
    
72. /* Set the DC bit according to ETH DeferralCheck value */
    $ ~0 D* z" [* H2 q8 a, _8 I
73. tmpreg |= (uint32_t)(macinit.Watchdog |
    
74. macinit.Jabber |
    
75. macinit.InterFrameGap |
    
76. macinit.CarrierSense |
    & g1 C$ V6 C2 T7 l. i3 j. j- O
77. (heth->Init).Speed |
    
78. macinit.ReceiveOwn |
    - C$ Z  g) s2 x; T; u6 X
79. macinit.LoopbackMode |
    % d4 ?/ R; G; {+ F# o' Z- O6 |1 R
80. (heth->Init).DuplexMode |
    
81. macinit.ChecksumOffload |
    9 }% V  i' n, H5 j9 j
82. macinit.RetryTransmission |
    
83. macinit.AutomaticPadCRCStrip |
    ) u  _, ^7 E/ e7 Z, l4 k5 ?# X
84. macinit.BackOffLimit |
    
85. macinit.DeferralCheck);
    ) c  Z1 a  x# w  j
86. 
    : b+ X! ~* R& U- P
87. /* Write to ETHERNET MACCR */
    * _$ }1 \) L9 O' t7 h
88. (heth->Instance)->MACCR = (uint32_t)tmpreg;
    : B, b! o- ?# G2 D
89. 
    
90. /* Wait until the write operation will be taken into account:
    $ F8 \' I' _) v6 |+ ?  ^
91. at least four TX_CLK/RX_CLK clock cycles */
    ( Z+ L: W+ }/ w7 C. G
92. tmpreg = (heth->Instance)->MACCR;
    * J2 h. c; P( f# F( e
93. HAL_Delay(ETH_REG_WRITE_DELAY);
    / L+ X* u( G+ u$ P$ [# n" e. z
94. (heth->Instance)->MACCR = tmpreg;
    
95. 
    
96. /*----------------------- ETHERNET MACFFR Configuration --------------------*/
    , j0 S* _, b- a; x$ q4 u# X2 n
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 */
    
100. /* Set the DBF bit according to ETH BroadcastFramesReception value */
     
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 */
     9 s! f3 v  w: A- ]0 |/ m
105. /* Write to ETHERNET MACFFR */
     
106. (heth->Instance)->MACFFR = (uint32_t)(macinit.ReceiveAll |
     
107. macinit.SourceAddrFilter |
     : U1 E  o3 D7 K  @/ G4 G
108. macinit.PassControlFrames |
     3 A% l/ E% `! z' J3 C- v
109. macinit.BroadcastFramesReception |
     % |# ^! y9 P4 i- U! K- |$ e0 V
110. macinit.DestinationAddrFilter |
     % N2 f. c5 z- _7 _, n' @
111. macinit.PromiscuousMode |
     
112. macinit.MulticastFramesFilter |
     
113. macinit.UnicastFramesFilter);
     2 M. Q+ i/ F. t9 k6 [
114. 
     
115. /* Wait until the write operation will be taken into account:
     
116. at least four TX_CLK/RX_CLK clock cycles */
     $ D- t  M) K3 c$ [- D- _
117. tmpreg = (heth->Instance)->MACFFR;
     7 U( H7 ]# ~0 I7 ~3 D
118. HAL_Delay(ETH_REG_WRITE_DELAY);
     
119. (heth->Instance)->MACFFR = tmpreg;
     
120. 
     + ^* I) u6 i0 R5 h) L
121. /*--------------- ETHERNET MACHTHR and MACHTLR Configuration --------------*/
     1 p" Q8 y9 E9 J' W8 @% x  ~
122. /* Write to ETHERNET MACHTHR */
     
123. (heth->Instance)->MACHTHR = (uint32_t)macinit.HashTableHigh;
     5 o+ w- }+ q* n. u7 ^6 U$ D& w
124. 
     
125. /* Write to ETHERNET MACHTLR */
     * ]% T0 a" H+ w: K
126. (heth->Instance)->MACHTLR = (uint32_t)macinit.HashTableLow;
     
127. /*----------------------- ETHERNET MACFCR Configuration -------------------*/
       v2 R# L9 _& g8 w
128. 
     ; l0 i! f+ n% z- Q" r* {
129. /* Get the ETHERNET MACFCR value */
     
130. tmpreg = (heth->Instance)->MACFCR;
     , D/ H+ W4 \+ n5 T& R
131. /* Clear xx bits */
     
132. tmpreg &= ETH_MACFCR_CLEAR_MASK;
     
133. 
     % t0 D/ ~# }4 [+ s
134. /* Set the PT bit according to ETH PauseTime value */
     ! O; T2 t/ a' w( b7 @; ^
135. /* Set the DZPQ bit according to ETH ZeroQuantaPause value */
     
136. /* Set the PLT bit according to ETH PauseLowThreshold value */
     - ?# {. I& p% V5 ~( a, b  K
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 */
     3 w, }9 N5 v9 E$ Q( }+ C6 A
140. tmpreg |= (uint32_t)((macinit.PauseTime Instance)->MACFCR = (uint32_t)tmpreg;
     7 w4 T: b  ]' Q! Q0 g) n9 F$ a
141. 
     - j; B# {/ h  @
142. /* Wait until the write operation will be taken into account:
     1 W( g$ F3 {+ S8 G8 y
143. at least four TX_CLK/RX_CLK clock cycles */
     " O% i( |" Z* C, q/ i6 r1 j# A
144. tmpreg = (heth->Instance)->MACFCR;
     
145. HAL_Delay(ETH_REG_WRITE_DELAY);
     ) F1 S! d: h7 L9 r" q% v8 {/ a
146. (heth->Instance)->MACFCR = tmpreg;
     
147. 
     + j8 T, W6 g* ~3 S  t( k' W/ q
148. /*----------------------- ETHERNET MACVLANTR Configuration ----------------*/
     3 x; Y# W+ U3 r
149. /* Set the ETV bit according to ETH VLANTagComparison value */
     6 J7 h. W* m% t; {; A* n
150. /* Set the VL bit according to ETH VLANTagIdentifier value */
     
151. (heth->Instance)->MACVLANTR = (uint32_t)(macinit.VLANTagComparison |
     
152. macinit.VLANTagIdentifier);
     
153. 
     
154. /* Wait until the write operation will be taken into account:
     
155.    at least four TX_CLK/RX_CLK clock cycles */
     ! y6 S# P$ y3 u$ |3 o/ a
156. tmpreg = (heth->Instance)->MACVLANTR;
     5 e% V$ y$ M! l2 ^$ x( z
157. HAL_Delay(ETH_REG_WRITE_DELAY);
     
158. (heth->Instance)->MACVLANTR = tmpreg;
     
159. 
     
160. /* Ethernet DMA default initialization ************************************/
     1 w6 l: }  b+ d, i
161. dmainit.DropTCPIPChecksumErrorFrame = ETH_DROPTCPIPCHECKSUMERRORFRAME_ENABLE;
     1 {% F* |: l! u6 P; M% a0 [
162. dmainit.ReceiveStoreForward = ETH_RECEIVESTOREFORWARD_ENABLE;
     % R* m$ k& O, }; R. e
163. dmainit.FlushReceivedFrame = ETH_FLUSHRECEIVEDFRAME_ENABLE;
     
164. dmainit.TransmitStoreForward = ETH_TRANSMITSTOREFORWARD_ENABLE;
     # R: {$ N& Z  t- j- L/ {
165. dmainit.TransmitThresholdControl = ETH_TRANSMITTHRESHOLDCONTROL_64BYTES;
     
166. dmainit.ForwardErrorFrames = ETH_FORWARDERRORFRAMES_DISABLE;
     $ t' M+ B# L+ \
167. dmainit.ForwardUndersizedGoodFrames = ETH_FORWARDUNDERSIZEDGOODFRAMES_DISABLE;
     1 g( k: u" Q  [
168. dmainit.ReceiveThresholdControl = ETH_RECEIVEDTHRESHOLDCONTROL_64BYTES;
     
169. dmainit.SecondFrameOperate = ETH_SECONDFRAMEOPERARTE_ENABLE;
     & q, Y1 r% `4 J( G6 I& H. W
170. dmainit.AddressAlignedBeats = ETH_ADDRESSALIGNEDBEATS_ENABLE;
     5 J) R5 x& H$ r9 q3 T
171. dmainit.FixedBurst = ETH_FIXEDBURST_ENABLE;
     
172. dmainit.RxDMABurstLength = ETH_RXDMABURSTLENGTH_32BEAT;
     
173. dmainit.TxDMABurstLength = ETH_TXDMABURSTLENGTH_32BEAT;
     $ B0 a; _$ P0 c! Z
174. dmainit.EnhancedDescriptorFormat = ETH_DMAENHANCEDDESCRIPTOR_ENABLE;
     0 [5 m) Q2 {# y- w" H& {
175. dmainit.DescriptorSkipLength = 0x0;
       o3 ^1 H& X( @2 U
176. dmainit.DMAArbitration = ETH_DMAARBITRATION_ROUNDROBIN_RXTX_1_1;
     9 U* T5 O/ z4 F, ?* Z3 T
177. 
     0 R' w$ e; ?- l9 H0 U
178. /* Get the ETHERNET DMAOMR value */
     , [8 h* G) d* \6 \8 R/ ^" B; t
179. tmpreg = (heth->Instance)->DMAOMR;
     
180. /* Clear xx bits */
     # y1 J( U. m" W/ m( Y# s
181. tmpreg &= ETH_DMAOMR_CLEAR_MASK;
     
182. 
     2 \1 I, n9 Y$ F" Z: ^
183. /* Set the DT bit according to ETH DropTCPIPChecksumErrorFrame value */
     
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 */
     * [: N( W" R7 v0 a: J
188. /* Set the FEF bit according to ETH ForwardErrorFrames value */
     
189. /* Set the FUF bit according to ETH ForwardUndersizedGoodFrames value */
     5 V9 ?; `& B# x/ I4 {
190. /* Set the RTC bit according to ETH ReceiveThresholdControl value */
     
191. /* Set the OSF bit according to ETH SecondFrameOperate value */
     
192. tmpreg |= (uint32_t)(dmainit.DropTCPIPChecksumErrorFrame |
     5 R( o0 U' ?' X% v! Y- b/ J; }
193.                      dmainit.ReceiveStoreForward |
     1 M3 w% \; z1 d7 u$ T, z
194.                      dmainit.FlushReceivedFrame |
     
195.                      dmainit.TransmitStoreForward |
     
196.                      dmainit.TransmitThresholdControl |
     
197.                      dmainit.ForwardErrorFrames |
     ; j% }& ?( J( v- _
198.                      dmainit.ForwardUndersizedGoodFrames |
     
199.                      dmainit.ReceiveThresholdControl |
     
200.                      dmainit.SecondFrameOperate);
     
201. 
     
202. /* Write to ETHERNET DMAOMR */
     
203. (heth->Instance)->DMAOMR = (uint32_t)tmpreg;
     
204. 
     
205. /* Wait until the write operation will be taken into account:
     
206.    at least four TX_CLK/RX_CLK clock cycles */
     + a6 d8 i* e* q- M- z
207. tmpreg = (heth->Instance)->DMAOMR;
     
208. HAL_Delay(ETH_REG_WRITE_DELAY);
     
209. (heth->Instance)->DMAOMR = tmpreg;
     
210. 
     
211. /*----------------------- ETHERNET DMABMR Configuration ------------------*/
     
212. /* Set the AAL bit according to ETH AddressAlignedBeats value */
     
213. /* Set the FB bit according to ETH FixedBurst value */
     
214. /* Set the RPBL and 4*PBL bits according to ETH RxDMABurstLength value */
     7 a) c/ m* E' M
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*/
     1 V* Z! s8 X4 M
217. /* Set the DSL bit according to ETH DesciptorSkipLength value */
     / G/ ]" D/ I! O- x  _! _* h
218. /* Set the PR and DA bits according to ETH DMAArbitration value */
     2 f; V/ H& V8 B6 k
219. (heth->Instance)->DMABMR = (uint32_t)(dmainit.AddressAlignedBeats |
     4 X- j. W) D( z# w
220.                                       dmainit.FixedBurst |
     % \; T! Q( V, L+ P3 o6 [
221.                                       dmainit.RxDMABurstLength |    /* !! if 4xPBL is selected for Tx or Rx it is applied for the other */
     ) I2 Q  ?" V/ X8 Z8 a
222.                                       dmainit.TxDMABurstLength |
     8 X$ i$ @3 H& Q6 Z. @8 ?
223.                                       dmainit.EnhancedDescriptorFormat |
     
224.                                       (dmainit.DescriptorSkipLength Instance)->DMABMR;
     % C3 Q; ]0 X# ], f) \  u* B7 y
225. HAL_Delay(ETH_REG_WRITE_DELAY);
     % M5 W5 y) c" _& j4 J6 [
226. (heth->Instance)->DMABMR = tmpreg;
     0 W7 D" e& T  v2 V; o, A
227. 
     7 |5 C) Q: ~6 Z6 t2 J0 ]* o# p3 V
228. if((heth->Init).RxMode == ETH_RXINTERRUPT_MODE)
     $ i( ]7 g. _- p0 _8 }
229. {
     + w1 z! z5 r) [* A% A& I2 X
230.    /* Enable the Ethernet Rx Interrupt */
     
231.    __HAL_ETH_DMA_ENABLE_IT((heth), ETH_DMA_IT_NIS | ETH_DMA_IT_R);
       F! A" ]% G7 [2 v2 L  |! F
232. }
     
233. 
     ( d' S, B! O8 P' ~* j: I9 U- J+ V
234. /* Initialize MAC address in ethernet MAC */
     
235. ETH_MACAddressConfig(heth, ETH_MAC_ADDRESS0, heth->Init.MACAddr);
     ( X: P+ a" ]/ n' F% o; n
236. }

复制代码

5 E8 g! O. e9 D. t1 r. z* D! A这里我就要稍微吐槽一下HAL库了
MAC层过滤的设置没有预留接口出来，有设置MAC地址的函数

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

: q& l9 f# R( z( m就不多做一个设置MAC层过滤的函数嘛，连后面用到的宏定义都有~~

木有办法，自己编一个初始化MAC层过滤的函数吧

其实也就是把上面这个ETH_MACDMAConfig函数分离成两个单独的设置函数，再编一个设置MAC层过滤的函数
; o9 d/ ~$ B6 T4 M4 h
& S: U* ~9 R: m9 O# g8 O开启MAC层过滤的初始化代码

1. uint8_t ETH_MAC_Setting(ETH_HandleTypeDef *heth)
   
2. {
   
3. ETH_MACInitTypeDef macinit;
   4 W# W# }) P% }; R7 v) ~5 t/ ?. E
4. /* Ethernet MAC default initialization **************************************/
   
5. macinit.Watchdog = ETH_WATCHDOG_ENABLE;
   
6. macinit.Jabber = ETH_JABBER_ENABLE;
   . f8 G. K( |0 s" H3 t; m* S) H
7. macinit.InterFrameGap = ETH_INTERFRAMEGAP_96BIT;
   
8. macinit.CarrierSense = ETH_CARRIERSENCE_ENABLE;
   
9. macinit.ReceiveOwn = ETH_RECEIVEOWN_ENABLE;
   
10. macinit.LoopbackMode = ETH_LOOPBACKMODE_DISABLE;
    - ]( ]' o6 A% Q' m, C4 `6 @
11. if (heth->Init.ChecksumMode == ETH_CHECKSUM_BY_HARDWARE)
    
12. {
    
13. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_ENABLE;
    
14. }
    
15. else
    9 ?; N+ n- [% C
16. {
      F/ j( w% d$ s" @' a% N$ q: N
17. macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_DISABLE;
      N; Z9 W# }+ N2 e, m+ g. \
18. }
    
19. macinit.RetryTransmission = ETH_RETRYTRANSMISSION_ENABLE;          //使能重传
    7 O1 u* A5 b" N; u( Q
20. macinit.AutomaticPadCRCStrip = ETH_AUTOMATICPADCRCSTRIP_ENABLE;          //使能自动去除
    
21. macinit.BackOffLimit = ETH_BACKOFFLIMIT_10;
    & ^  Z( ^8 \2 s: Z- D! V5 T( a5 k% _
22. macinit.DeferralCheck = ETH_DEFFERRALCHECK_DISABLE;
    
23. macinit.ReceiveAll = ETH_RECEIVEAll_DISABLE; ///不接收所有包
    
24. macinit.SourceAddrFilter = ETH_SOURCEADDRFILTER_NORMAL_ENABLE; //源地址过滤
    : K! I) P2 s. [  B
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; //混乱模式
    1 F1 H; }! h, g9 S' [+ f
29. macinit.MulticastFramesFilter = ETH_MULTICASTFRAMESFILTER_PERFECT; //多播过滤
    
30. macinit.UnicastFramesFilter = ETH_UNICASTFRAMESFILTER_PERFECT; //单播过滤
    " b/ h$ v1 r0 d5 r
31. macinit.HashTableHigh = 0x0; //Hash表高位
    6 u) C9 M' Y; P& z
32. macinit.HashTableLow = 0x0; //Hash表低位
    ' M6 ]6 l1 \" p! `1 Z/ p7 R
33. macinit.PauseTime = 0x0;
    4 L3 F- S! e* M
34. macinit.ZeroQuantaPause = ETH_ZEROQUANTAPAUSE_DISABLE;
    
35. macinit.PauseLowThreshold = ETH_PAUSELOWTHRESHOLD_MINUS4;
    ' j+ |+ Y6 z( l* Y5 t$ j$ j) ^
36. macinit.UnicastPauseFrameDetect = ETH_UNICASTPAUSEFRAMEDETECT_ENABLE;
    " N; W1 j2 J( i/ k
37. macinit.ReceiveFlowControl = ETH_RECEIVEFLOWCONTROL_DISABLE; //接收流控
    
38. macinit.TransmitFlowControl = ETH_TRANSMITFLOWCONTROL_DISABLE; //发送流控
    . @* q5 P3 m8 m, i) A* T
39. macinit.VLANTagComparison = ETH_VLANTAGCOMPARISON_16BIT;
    
40. macinit.VLANTagIdentifier = 0x0;
    
41. 
    
42. return HAL_ETH_ConfigMAC(heth, &macinit);
    
43. }

复制代码

2 i, U  g3 |' q. |$ W) G( r默认的MAC层 DMA初始化函数

1. uint8_t ETH_DMA_Setting(ETH_HandleTypeDef *heth)
   ) c8 d2 r7 T; [0 I" X6 m3 m* z
2. {
   3 E$ f/ m3 Y7 _: F$ t; @
3. ETH_DMAInitTypeDef dmainit;
   
4. /* Ethernet DMA default initialization ************************************/
   
5. dmainit.DropTCPIPChecksumErrorFrame = ETH_DROPTCPIPCHECKSUMERRORFRAME_ENABLE;
   
6. dmainit.ReceiveStoreForward = ETH_RECEIVESTOREFORWARD_ENABLE;
   6 S; _1 B5 h( G6 L8 h
7. dmainit.FlushReceivedFrame = ETH_FLUSHRECEIVEDFRAME_ENABLE;
   
8. dmainit.TransmitStoreForward = ETH_TRANSMITSTOREFORWARD_ENABLE;
   / L/ C3 k1 {( p" h& T
9. dmainit.TransmitThresholdControl = ETH_TRANSMITTHRESHOLDCONTROL_64BYTES;
   
10. dmainit.ForwardErrorFrames = ETH_FORWARDERRORFRAMES_DISABLE;
      ^8 h/ M7 @0 X: l% R; Q$ ^8 [5 E
11. dmainit.ForwardUndersizedGoodFrames = ETH_FORWARDUNDERSIZEDGOODFRAMES_DISABLE;
    , i7 ^  w% w  M  W* e/ L/ Y
12. dmainit.ReceiveThresholdControl = ETH_RECEIVEDTHRESHOLDCONTROL_64BYTES;
    
13. dmainit.SecondFrameOperate = ETH_SECONDFRAMEOPERARTE_ENABLE;
    ) B- y- b/ E& F
14. dmainit.AddressAlignedBeats = ETH_ADDRESSALIGNEDBEATS_ENABLE;
    
15. dmainit.FixedBurst = ETH_FIXEDBURST_ENABLE;
    1 ^6 n, Z$ C$ Z+ k/ x( X
16. dmainit.RxDMABurstLength = ETH_RXDMABURSTLENGTH_32BEAT;
    + ^5 ?8 e; `  M0 @( H) ?- f2 A
17. dmainit.TxDMABurstLength = ETH_TXDMABURSTLENGTH_32BEAT;
    
18. dmainit.EnhancedDescriptorFormat = ETH_DMAENHANCEDDESCRIPTOR_ENABLE;
    
19. dmainit.DescriptorSkipLength = 0x0;
    
20. dmainit.DMAArbitration = ETH_DMAARBITRATION_ROUNDROBIN_RXTX_1_1;
    0 q5 F# W# ^1 u9 j5 P
21. uint8_t res =  HAL_ETH_ConfigDMA(heth, &dmainit);
    8 i* M. J3 ]# g8 P( B' L  c
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. }
    
27. return res;
    ; ]! |0 V/ e# f2 I9 G+ }" y
28. }

复制代码

4 J/ O6 c, ?% E. V; G7 r用来设置MAC地址的函数(其实就是把库函数的static函数取出来直接用了)

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

复制代码

然后到最最重要的MAC层过滤设置
& }2 g2 N4 W* ]# ?" \以MAC1为例

; a  H+ T# l5 G$ G; i* ]注意看红框的描述
% `! Y; O* ^* L( s2 v0 j; u! c功能很好用，可以过滤源地址/目的地址，还可以做掩码功能
设置MAC层过滤的代码

1. static void ETH_MAC_Filter_Setting(ETH_HandleTypeDef *heth,ST_ETH_PAR * para)
   
2. {
   
3.     //设置本机MAC地址
   & n0 `7 j) ^! l3 x, n. X- w/ M
4.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS0, heth->Init.MACAddr);
   ! {. K: G5 F  I& N; f( \$ f! U
5.     //设置UDP-A的对方MAC地址
   
6.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS1,para->UDP_A_MAC);
   , t" H1 b, V/ [7 v- g8 Q; b
7.     (heth->Instance)->MACA1HR|=0xC0000000;//需要完全匹配UDP-A的对方MAC才接收
   8 T* G; `, G* w0 T2 n; B" Z' M1 m% {2 W
8.     //设置UDP-B的对方MAC地址
   # P& i$ }8 J3 J/ q/ ]6 s" f
9.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS2,para->UDP_B_MAC);
   
10.     (heth->Instance)->MACA2HR|=0xC0000000;//需要完全匹配UDP-A的对方MAC才接收
    
11. }

复制代码

  ]( h4 N$ u9 o' `我这里是希望为我的两个UDP精确过滤接收到的源地址
所以AE位设置为1，SA设置为1，MBC全部为0(MAC地址全部检查)
8 g8 }2 j6 M7 `6 c6 F; F
4 L6 Y& S" v  z9 d假如我希望过滤MAC中特定的厂家字段
4 b  u1 \0 `% s& M* @0 G3 Q7 E) t例如某个MAC地址
01-02-03-04-05-06
其中01-02-03就是厂家字段

- B8 i; c( k# q. X9 A4 J* u那么代码要这样修改（MBC的第29位，28位，27位置1）
这样MAC层就不会检查MAC地址里后3个字节(04-05-06)
: w0 H' C( X- \% c; y4 i但是会检查前3个字节，也就是厂家字段
这里需要注意MAC地址的字节序
" H- B" Y; @& F' {5 l5 M7 q) b& x

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地址
   0 v" M- ?, D7 A  b6 @
6.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS1,para->UDP_A_MAC);
   
7.     (heth->Instance)->MACA1HR|=0xF8000000;//需要匹配厂家字段
   
8.     //设置UDP-B的对方MAC地址
   ' V4 l7 ?( f0 r. S7 @
9.     ETH_MAC_ADDR_Config(heth, ETH_MAC_ADDRESS2,para->UDP_B_MAC);
   ; c9 }: m" ~& n- O0 ]: o( Z
10.     (heth->Instance)->MACA2HR|=0xF8000000;//需要匹配厂家字段
    , t7 Q; R" D/ v/ P" {
11. }

复制代码

& o, v8 P  l; w! J3 n然后这些函数的调用顺序按:
1. HAL_ETH_Init
2. ETH_MAC_Setting
- }9 s5 v; |8 I* e3. ETH_DMA_Setting
4. ETH_MAC_Filter_Setting
" k  ~# r; T! c! g6 N* \# |
用你希望过滤的MAC传递到一个Hash计算函数里，得到一个值，通过这个值产生“映射”关系来过滤MAC地址，所以这个并不是精确的，因为可能会重复~~
# t4 D' Z; F4 Y% t4 B4 m
HASH函数
函数

1. / STM32 MACHASH - Copyright (C) 2014-2018 Clive Turvey (<a href="mailto:sourcer32@gmail.com">sourcer32@gmail.com</a>)
   
2. //  All Rights Reserved
   ; X) H2 b+ H+ @
3. 
     j  g# i* X6 p8 R4 c
4. #include <windows.h>
   ! M' R5 \+ B) ?5 f, Q' _
5. 
   
6. #include <stdio.h>
   2 Z) U& q  t6 M8 o( N& [3 t9 E
7. #include <stdlib.h>
   
8. 
   " q: i2 r  q) _3 R
9. typedef unsigned char uint8_t;
   
10. typedef unsigned long uint32_t;
    
11. 
    2 g( b0 h5 x4 P0 Y7 j+ V; V& i/ x
12. uint32_t Rev32(uint32_t x)
    
13. {
    
14.   uint32_t y;
    / D' ~; m  Z4 ~2 }* z
15.   int i;
    
16. 
    5 H  J" J0 O9 [9 x# P) T+ d/ F, s" [
17.   y = 0;
    
18. 
    
19.   for(i=0; i<32; i++)
    
20.     if (x & (1 << i))
    " _: X# T: m' @( }% d9 s
21.       y |= 1 << (31 - i);
    ; K) h/ e* e/ X" Z4 V
22. 
    
23.   return(y);
    
24. }
    5 B, ?" |' U" F% G( j7 h3 B
25. 
    
26. uint32_t MacHash(const uint8_t *Mac) // <a href="mailto:sourcer32@gmail.com">sourcer32@gmail.com</a>
    ; @( I  R# ?( b0 j8 T" k+ X, j
27. {
    : H6 L/ A5 ^8 ?4 f% R
28.   int i, j;
    ) F2 I9 r4 s- A8 s
29.   uint32_t Crc;
    
30. 
    
31.   Crc = 0xFFFFFFFF;
    # Z) }& i4 Z4 V7 Y
32. 
    
33.   for(j=0; j<6; j++)
    
34.   {
    
35.     Crc = Crc ^ (uint32_t)Mac[j];
    9 b- L0 \' m) n& S1 H7 h0 U' j/ t
36. 
    + c. @5 U" [" j. o  ~. H4 l
37.     for(i=0; i<8; i++)
    
38.       if (Crc & 1)
    2 o( e9 @; a0 @& f/ R% X
39.         Crc = (Crc >> 1) ^ 0xEDB88320; // Reversed 0x04C11DB7
    * P7 L) E" W+ @5 u" a0 ^. S
40.       else
    0 A/ B, l% f0 ~' N* n
41.         Crc = (Crc >> 1);
    ; i+ K- e( g, J2 N7 o: j
42.   }
    - R$ H/ E% Y1 B4 u' k: c" T' H
43. 
    
44.   return(Rev32(~Crc) >> 26); // Get High order 6-bit in reversed/inverted CRC
    
45. }
    ; o" G9 y% N" ^0 ~
46. 
    
47. uint32_t MacHashFast(const uint8_t *Mac) // <a href="mailto:sourcer32@gmail.com">sourcer32@gmail.com</a>
    
48. {
    . f! X. s; {8 w$ ?7 M
49.   static const uint32_t Rev6Tbl[] = {
    
50.     0x00,0x20,0x10,0x30,0x08,0x28,0x18,0x38,
    
51.     0x04,0x24,0x14,0x34,0x0C,0x2C,0x1C,0x3C,
    3 h7 C2 l" b/ y+ n; i* {
52.     0x02,0x22,0x12,0x32,0x0A,0x2A,0x1A,0x3A,
    * H7 Z! s2 A; ^+ W+ M! @
53.     0x06,0x26,0x16,0x36,0x0E,0x2E,0x1E,0x3E,
    
54.     0x01,0x21,0x11,0x31,0x09,0x29,0x19,0x39,
    
55.     0x05,0x25,0x15,0x35,0x0D,0x2D,0x1D,0x3D,
    
56.     0x03,0x23,0x13,0x33,0x0B,0x2B,0x1B,0x3B,
    
57.     0x07,0x27,0x17,0x37,0x0F,0x2F,0x1F,0x3F };
    0 ~3 B- _- ^- a( z1 X! D9 W
58. 
    ; n% m4 [7 @- ~6 K2 Q  x5 p, N8 R5 {
59.   static const uint32_t Crc32Tbl[] = {
    
60.     0x4DBDF21C, 0x500AE278, 0x76D3D2D4, 0x6B64C2B0,
    ( y' K: _2 F* I# p; _
61.     0x3B61B38C, 0x26D6A3E8, 0x000F9344, 0x1DB88320,
    
62.     0xA005713C, 0xBDB26158, 0x9B6B51F4, 0x86DC4190,
    
63.     0xD6D930AC, 0xCB6E20C8, 0xEDB71064, 0xF0000000 };
    
64. 
    
65.   int i;
    
66.   uint32_t Crc;
    
67. 
    ( _* k1 y" j; I& w( K
68.   Crc = 0;
    / N) k# e1 W  c
69. 
    
70.   for(i=0; i<6; i++)
    3 {/ a* g3 D! l5 W
71.   {
    8 ]0 y4 j" x4 n* |4 m; q
72.     Crc = Crc ^ (uint32_t)Mac<i>;
    ) e1 a0 T4 N% X1 q0 r, C% W
73. 
    1 c6 _1 i2 D, Q1 g' b2 a
74. </i>   Crc = (Crc >> 4) ^ Crc32Tbl[Crc & 0x0F];  /* lower nibble */
    
75.     Crc = (Crc >> 4) ^ Crc32Tbl[Crc & 0x0F];  /* upper nibble */
    & g; o: a/ Z. K5 F* P  A$ [
76.   }
    
77. 
    
78.   return(Rev6Tbl[Crc & 0x3F]);
    2 v; ]; t3 A" t4 ^0 M8 [/ L- v
79. }
    $ Q' P8 v7 s7 V% H: z
80. 
    $ ?# }/ k" e3 j6 }8 r% n! |
81. int main(int argc, char **argv)
    
82. {
    2 y. e' z% s4 S) c) P: Z, C" X; ~
83.   static const uint8_t Test1[] = { 0x1F, 0x52, 0x41, 0x9C, 0xB6, 0xAF }; // 0x2C
    
84.   static const uint8_t Test2[] = { 0xA0, 0x0A, 0x98, 0x00, 0x00, 0x45 }; // 0x07
    / K- A' y2 l; _' [% |
85.   static const uint8_t Test3[] = { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x21 }; // 0x24
    $ O( z% o, m& Y# T- M* ^  x  }
86. 
    
87.   printf("MacHash %02X\n", MacHash(Test1));
    
88.   printf("MacHash %02X\n", MacHash(Test2));
    & F. u" }  }/ [8 n6 m( I
89.   printf("MacHash %02X\n", MacHash(Test3));
      k, ^' I/ i3 k* }. G
90. 
    
91.   printf("MacHashFast %02X\n", MacHashFast(Test1));
    
92.   printf("MacHashFast %02X\n", MacHashFast(Test2));
    
93.   printf("MacHashFast %02X\n", MacHashFast(Test3));
    , S6 Q( E5 z5 {& `/ I/ X
94. 
    # \+ l* y% O) k2 k2 N
95.   return(1);
    0 @; j: U! \; ?: e$ J% T& q) _
96. }

复制代码

回到手册

' L( |0 U, ?! u# T2 D. }! J

9 f% c& C2 l  o2 \( ^$ |' h7 M

8 f0 [2 R1 \  a. ]+ M
3 g1 ~4 |7 M, H+ _
. k( F4 }) o" `1 B4 k+ V7 Q/ [) c上面的函数算出来一个数，假如是手册上的那个0x2c,二进制为101100B
: O$ {1 m3 f# z) P2 z4 \9 s换句看得懂的人话···就是：
算出来的数先看第6位
. S: c/ p5 a9 q& l是1的话说明用到的是HASH表高位寄存器
' W. b0 [3 i  A. d' `否则用到的是HASH表低位寄存器
3 |0 t, Y+ E5 M/ ?然后剩下的5位，转成十进制不是12嘛
& y+ v1 z, r2 A! K# G4 V- H# ~; `如果你希望过滤这个MAC
那么你就把对应的HASH表高/低位寄存器的对应位置1，否则置0
这里的0x2c就是要把
! g$ m6 V) w& ?" {* l- }; v) SHASH表高位寄存器的第12位置1
就可以过滤这条MAC了
然后把你希望的MAC地址都按照上面说的方法弄完
% i8 n( P- z: p  a7 x
/ V- Y6 Q- V* Q' _' t" k回到这个函数稍微改一下
# Q0 n$ b2 l9 @: o5 D) \

1. uint8_t ETH_MAC_Setting(ETH_HandleTypeDef *heth)
   7 s& t1 Z; b; {( k2 a
2. {
   
3.     ETH_MACInitTypeDef macinit;
   0 \* ~; z1 {1 p
4.     /* Ethernet MAC default initialization **************************************/
   % D  z0 H# R5 z/ n+ _
5.     macinit.Watchdog = ETH_WATCHDOG_ENABLE;
   : A! V/ U+ Z7 E6 |% o
6.     macinit.Jabber = ETH_JABBER_ENABLE;
   
7.     macinit.InterFrameGap = ETH_INTERFRAMEGAP_96BIT;
   . n$ ]% u/ O% Z5 N9 h
8.     macinit.CarrierSense = ETH_CARRIERSENCE_ENABLE;
   
9.     macinit.ReceiveOwn = ETH_RECEIVEOWN_ENABLE;
   # q3 d! h; ]7 s1 |
10.     macinit.LoopbackMode = ETH_LOOPBACKMODE_DISABLE;
    5 z' M" Q# S: ~9 {; T9 h& [
11.     if (heth->Init.ChecksumMode == ETH_CHECKSUM_BY_HARDWARE)
    
12.     {
    % K+ c! q- u, N3 |3 {) ?% ]
13.         macinit.ChecksumOffload = ETH_CHECKSUMOFFLAOD_ENABLE;
    
14.     }
    
15.     else
    
16.     {
    6 F4 _9 V3 m9 P: v* l
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;
    ( r8 L, ^' C8 @- R0 S* 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; //广播不接收
    3 P3 c4 d2 \( ^
27.     macinit.DestinationAddrFilter = ETH_DESTINATIONADDRFILTER_NORMAL; //目的地址过滤
    
28.     macinit.PromiscuousMode = ETH_PROMISCUOUS_MODE_DISABLE; //混乱模式
    7 q) l2 q4 n2 u3 n. [2 X$ ]) k8 E
29.     macinit.MulticastFramesFilter = ETH_MULTICASTFRAMESFILTER_PERFECTHASHTABLE; //！！多播HASH完美过滤
    5 `4 S, R5 H* y6 {+ a9 n1 n
30.     macinit.UnicastFramesFilter = ETH_UNICASTFRAMESFILTER_PERFECTHASHTABLE; //！！单播HASH完美过滤
      s; s7 j" f6 q; V% X
31.     macinit.HashTableHigh = 0x0; //！！填你最后算完的Hash表高位
    ) y+ Q6 }* {0 H" m9 |# @
32.     macinit.HashTableLow = 0x0; //！！填你最后算完的Hash表低位
    8 `# h8 ?: V9 S: q, K* K
33.     macinit.PauseTime = 0x0;
    
34.     macinit.ZeroQuantaPause = ETH_ZEROQUANTAPAUSE_DISABLE;
    1 g+ J7 L0 {/ j. F) L( M
35.     macinit.PauseLowThreshold = ETH_PAUSELOWTHRESHOLD_MINUS4;
    / P5 t& U3 j: y/ T- y
36.     macinit.UnicastPauseFrameDetect = ETH_UNICASTPAUSEFRAMEDETECT_ENABLE;
    $ Y  A" \# `8 v" ~
37.     macinit.ReceiveFlowControl = ETH_RECEIVEFLOWCONTROL_DISABLE; //接收流控
    
38.     macinit.TransmitFlowControl = ETH_TRANSMITFLOWCONTROL_DISABLE; //发送流控
    $ G* w5 ^, U$ c
39.     macinit.VLANTagComparison = ETH_VLANTAGCOMPARISON_16BIT;
    
40.     macinit.VLANTagIdentifier = 0x0;
    & ?0 ?. v" G3 C
41. 
    , J0 }: i5 l" m9 M: ]) p: j
42.     return HAL_ETH_ConfigMAC(heth, &macinit);
    / {* t4 S4 e4 R: S9 `8 D
43. }

复制代码

7 z" l  U5 t, B- I大概MAC层过滤就这些东西了
& g2 l7 T4 u$ y# o, {" d如果有条件弄MAC层过滤真的强烈建议开启，可以大幅减轻协议栈的处理负担，板卡不会因为处理大量无用的数据而白白浪费处理性能。
4 h6 z* q& C9 H
' o, \" O/ u$ D; i; i! o

0 n! ~) [' @/ a5 Q# A
7 N% a  `3 P# T. f8 U