请教一个lpc1768官方以太网驱动接收数据帧的问题

zhongshu_1988

一、硬件：
开发板用的是微雪的open1768，lpc1768的芯片；
以太网物理芯片用的是DP83848；

二、驱动：
驱动用的是lpc官方驱动包：lpc175x_6x_cmsis_driver_library

三、方案：
我在测试接收以太网数据帧，用一台linux笔记本写了一个以太网帧发送程序，每隔一秒向开发板发送一个以太网帧。然后，设置断点，测试接收情况。

四、源文件：
1. emactest.c

1. #include "string.h"
   
2. #include "crc32.h"
   
3. #include "lpc17xx_emac.h"
   
4. #include "lpc17xx_gpio.h"
   
5. #include "lpc17xx_pinsel.h"
   
6. #include "lpc17xx_libcfg.h"
   
7. 
   
8. /*目标：接收一个以太网帧，然后把该帧发送回去*/
   
9. 
   
10. /* This is the MAC address of LPC1768 */
    
11. #define EMAC_ADDR12                0x00006666
    
12. #define EMAC_ADDR34                0x00006666
    
13. #define EMAC_ADDR56                0x00006666
    
14. /* A pseudo destination MAC address is defined for
    
15. * both TX_ONLY and BOUNCE_RX test */
    
16. #define EMAC_DST_ADDR12                0x0000E386
    
17. #define EMAC_DST_ADDR34                0x00006BDA
    
18. #define EMAC_DST_ADDR56                0x00005000
    
19. 
    
20. 
    
21. /* INTERNAL MACROS ----------------------------------------------- */
    
22. 
    
23. #define TX_PACKET_SIZE                114
    
24. 
    
25. #define MYMAC_1         ((EMAC_ADDR12 & 0xFF00) >> 8)
    
26. #define MYMAC_2         ((EMAC_ADDR12 & 0xFF))
    
27. #define MYMAC_3         ((EMAC_ADDR34 & 0xFF00) >> 8)
    
28. #define MYMAC_4         ((EMAC_ADDR34 & 0xFF))
    
29. #define MYMAC_5         ((EMAC_ADDR56 & 0xFF00) >> 8)
    
30. #define MYMAC_6         ((EMAC_ADDR56 & 0xFF))
    
31. 
    
32. 
    
33. /*  PRIVATE VARIABLES ----------------------------------------------- */
    
34. /* Global Tx Buffer data 应用程序发送缓冲区*/
    
35. uint8_t __attribute__ ((aligned (4))) gTxBuf[TX_PACKET_SIZE + 0x10];
    
36. /* Global Rx Buffer data 应用程序发送缓冲区*/
    
37. uint8_t __attribute__ ((aligned (4))) gRxBuf[TX_PACKET_SIZE + 0x10];
    
38. 
    
39. 
    
40. /* EMAC address */
    
41. uint8_t EMACAddr[] = {MYMAC_6, MYMAC_5, MYMAC_4, MYMAC_3, MYMAC_2, MYMAC_1};
    
42. 
    
43. /* Tx, Rx Counters */
    
44. __IO uint32_t RXOverrunCount = 0;
    
45. __IO uint32_t RXErrorCount = 0;
    
46. __IO uint32_t TXUnderrunCount = 0;
    
47. __IO uint32_t TXErrorCount = 0;
    
48. __IO uint32_t RxFinishedCount = 0;
    
49. __IO uint32_t TxFinishedCount = 0;
    
50. __IO uint32_t TxDoneCount = 0;
    
51. __IO uint32_t RxDoneCount = 0;
    
52. __IO uint32_t ReceiveLength = 0;
    
53. __IO Bool PacketReceived = FALSE;
    
54. 
    
55. /************************** PRIVATE FUNCTON **********************************/
    
56. /* Interrupt service routines */
    
57. void ENET_IRQHandler (void);
    
58. 
    
59. void PacketGen(uint8_t *txptr);
    
60. void Usr_Init_Emac(void);
    
61. 
    
62. /*----------------- INTERRUPT SERVICE ROUTINES --------------------------*/
    
63. /*********************************************************************//**
    
64. * @brief                Ethernet service routine handler
    
65. * @param[in]        none
    
66. * @return                 none
    
67. **********************************************************************/
    
68. void ENET_IRQHandler (void)
    
69. {
    
70.         EMAC_PACKETBUF_Type RxDatbuf;
    
71.         uint32_t RxLen;
    
72. 
    
73.         /* EMAC Ethernet Controller Interrupt function. */
    
74.         uint32_t int_stat;
    
75.         // Get EMAC interrupt status
    
76.         while ((int_stat = (LPC_EMAC->IntStatus & LPC_EMAC->IntEnable)) != 0) {
    
77.                 // Clear interrupt status
    
78.                 LPC_EMAC->IntClear = int_stat;
    
79.                 /* scan interrupt status source */
    
80. 
    
81.                 /* ---------- receive overrun ------------*/
    
82.                 if((int_stat & EMAC_INT_RX_OVERRUN))
    
83.                 {
    
84.                         RXOverrunCount++;
    
85.                 }
    
86. 
    
87.                 /*-----------  receive error -------------*/
    
88.                 /* Note:
    
89.                  * The EMAC doesn't distinguish the frame type and frame length,
    
90.                  * so, e.g. when the IP(0x8000) or ARP(0x0806) packets are received,
    
91.                  * it compares the frame type with the max length and gives the
    
92.                  * "Range" error. In fact, this bit is not an error indication,
    
93.                  * but simply a statement by the chip regarding the status of
    
94.                  * the received frame
    
95.                  */
    
96.                 if ((int_stat & EMAC_INT_RX_ERR))
    
97.                 {
    
98.                         if (EMAC_CheckReceiveDataStatus(EMAC_RINFO_RANGE_ERR) == RESET){
    
99.                                 RXErrorCount++;
    
100.                         }
     
101.                 }
     
102. 
     
103.                 /* ---------- RX Finished Process Descriptors ----------*/
     
104.                 if ((int_stat & EMAC_INT_RX_FIN))
     
105.                 {
     
106.                         RxFinishedCount++;
     
107.                 }
     
108. 
     
109.                 /* ---------- Receive Done -----------------------------*/
     
110.                 /* Note: All packets are greater than (TX_PACKET_SIZE + 4)
     
111.                  * will be ignore!
     
112.                  */
     
113.                 if ((int_stat & EMAC_INT_RX_DONE))
     
114.                 {
     
115.                         /* Packet received, check if packet is valid. */
     
116.                         if (EMAC_CheckReceiveIndex()){
     
117.                                 if (!EMAC_CheckReceiveDataStatus(EMAC_RINFO_LAST_FLAG)){
     
118.                                         goto rel;
     
119.                                 }
     
120.                                 // Get data size, trip out 4-bytes CRC field, note that length in (-1) style format
     
121.                                 RxLen = EMAC_GetReceiveDataSize() - 3;
     
122.                                 // Note that packet added 4-bytes CRC created by yourself
     
123.                                 if ((RxLen > (TX_PACKET_SIZE + 4)) || (EMAC_CheckReceiveDataStatus(EMAC_RINFO_SYM_ERR))) {
     
124.                                         /* Invalid frame, ignore it and free buffer */
     
125.                                         goto rel;
     
126.                                 }
     
127.                                 ReceiveLength = RxLen;
     
128.                                 // Valid Frame, just copy it
     
129.                                 RxDatbuf.pbDataBuf = (uint32_t *)gRxBuf;
     
130.                                 RxDatbuf.ulDataLen = RxLen;
     
131.                                 EMAC_ReadPacketBuffer(&RxDatbuf);
     
132.                                 PacketReceived = TRUE;
     
133. 
     
134.                 rel:
     
135.                                 /* Release frame from EMAC buffer */
     
136.                                 EMAC_UpdateRxConsumeIndex();
     
137.                         }
     
138.                         RxDoneCount++;
     
139.                 }
     
140. 
     
141.                 /*------------------- Transmit Underrun -----------------------*/
     
142.                 if ((int_stat & EMAC_INT_TX_UNDERRUN))
     
143.                 {
     
144.                         TXUnderrunCount++;
     
145.                 }
     
146. 
     
147.                 /*------------------- Transmit Error --------------------------*/
     
148.                 if ((int_stat & EMAC_INT_TX_ERR))
     
149.                 {
     
150.                         TXErrorCount++;
     
151.                 }
     
152. 
     
153.                 /* ----------------- TX Finished Process Descriptors ----------*/
     
154.                 if ((int_stat & EMAC_INT_TX_FIN))
     
155.                 {
     
156.                         TxFinishedCount++;
     
157.                 }
     
158. 
     
159.                 /* ----------------- Transmit Done ----------------------------*/
     
160.                 if ((int_stat & EMAC_INT_TX_DONE))
     
161.                 {
     
162.                         TxDoneCount++;
     
163.                 }
     
164.         }
     
165. }
     
166. 
     
167. 
     
168. /*-------------------------PRIVATE FUNCTIONS-----------------------------------*/
     
169. /*********************************************************************//**
     
170. * @brief                Create a perfect packet for TX
     
171. * @param[in]        pointer to TX packet
     
172. * @return                 none
     
173. **********************************************************************/
     
174. void PacketGen( uint8_t *txptr )
     
175. {
     
176.   int i;
     
177.   uint32_t crcValue;
     
178.   uint32_t BodyLength = TX_PACKET_SIZE - 14;
     
179. 
     
180.   /* Dest address */
     
181.   *(txptr+0) = EMAC_DST_ADDR56 & 0xFF;
     
182.   *(txptr+1) = (EMAC_DST_ADDR56 >> 0x08) & 0xFF;
     
183.   *(txptr+2) = EMAC_DST_ADDR34 & 0xFF;
     
184.   *(txptr+3) = (EMAC_DST_ADDR34 >> 0x08) & 0xFF;
     
185.   *(txptr+4) = EMAC_DST_ADDR12 & 0xFF;
     
186.   *(txptr+5) = (EMAC_DST_ADDR12 >> 0x08) & 0xFF;
     
187. 
     
188.   /* Src address */
     
189.   *(txptr+6) = EMAC_ADDR56 & 0xFF;
     
190.   *(txptr+7) = (EMAC_ADDR56 >> 0x08) & 0xFF;
     
191.   *(txptr+8) = EMAC_ADDR34 & 0xFF;
     
192.   *(txptr+9) = (EMAC_ADDR34 >> 0x08) & 0xFF;
     
193.   *(txptr+10) = EMAC_ADDR12 & 0xFF;
     
194.   *(txptr+11) = (EMAC_ADDR12 >> 0x08) & 0xFF;
     
195. 
     
196.   /* Type or length, body length is TX_PACKET_SIZE - 14 bytes */
     
197.   *(txptr+12) = BodyLength & 0xFF;
     
198.   *(txptr+13) = (BodyLength >> 0x08) & 0xFF;
     
199. 
     
200.   /* Skip the first 14 bytes for dst, src, and type/length */
     
201.   for ( i=0; i < BodyLength; i++ )
     
202.   {
     
203.         *(txptr+i+14) = 0x55;
     
204.   }
     
205. 
     
206.   // Calculate CRC
     
207.   crcValue = crc32_bfr( txptr, TX_PACKET_SIZE );
     
208. 
     
209.   // Add 4-byte CRC
     
210.   *(txptr+TX_PACKET_SIZE) = (0xff & crcValue);
     
211.   *(txptr+TX_PACKET_SIZE+1) = 0xff & (crcValue >> 8 );
     
212.   *(txptr+TX_PACKET_SIZE+2) = 0xff & (crcValue >> 16);
     
213.   *(txptr+TX_PACKET_SIZE+3) = 0xff & (crcValue >> 24);
     
214. }
     
215. 
     
216. 
     
217. /*********************************************************************//**
     
218. * @brief                User EMAC initialize
     
219. * @param[in]        none
     
220. * @return                 none
     
221. **********************************************************************/
     
222. void Usr_Init_Emac(void)
     
223. {
     
224.         /* EMAC configuration type */
     
225.         EMAC_CFG_Type Emac_Config;
     
226.         /* pin configuration */
     
227.         PINSEL_CFG_Type PinCfg;
     
228.         uint32_t i;
     
229.         /*
     
230.          * Enable P1 Ethernet Pins:
     
231.          * P1.0 - ENET_TXD0
     
232.          * P1.1 - ENET_TXD1
     
233.          * P1.4 - ENET_TX_EN
     
234.          * P1.8 - ENET_CRS
     
235.          * P1.9 - ENET_RXD0
     
236.          * P1.10 - ENET_RXD1
     
237.          * P1.14 - ENET_RX_ER
     
238.          * P1.15 - ENET_REF_CLK
     
239.          * P1.16 - ENET_MDC
     
240.          * P1.17 - ENET_MDIO
     
241.          */
     
242.         PinCfg.Funcnum = 1;
     
243.         PinCfg.OpenDrain = 0;
     
244.         PinCfg.Pinmode = 0;
     
245.         PinCfg.Portnum = 1;
     
246. 
     
247.         PinCfg.Pinnum = 0;
     
248.         PINSEL_ConfigPin(&PinCfg);
     
249.         PinCfg.Pinnum = 1;
     
250.         PINSEL_ConfigPin(&PinCfg);
     
251.         PinCfg.Pinnum = 4;
     
252.         PINSEL_ConfigPin(&PinCfg);
     
253.         PinCfg.Pinnum = 8;
     
254.         PINSEL_ConfigPin(&PinCfg);
     
255.         PinCfg.Pinnum = 9;
     
256.         PINSEL_ConfigPin(&PinCfg);
     
257.         PinCfg.Pinnum = 10;
     
258.         PINSEL_ConfigPin(&PinCfg);
     
259.         PinCfg.Pinnum = 14;
     
260.         PINSEL_ConfigPin(&PinCfg);
     
261.         PinCfg.Pinnum = 15;
     
262.         PINSEL_ConfigPin(&PinCfg);
     
263.         PinCfg.Pinnum = 16;
     
264.         PINSEL_ConfigPin(&PinCfg);
     
265.         PinCfg.Pinnum = 17;
     
266.         PINSEL_ConfigPin(&PinCfg);
     
267. 
     
268.         Emac_Config.Mode = EMAC_MODE_AUTO;
     
269.         Emac_Config.pbEMAC_Addr = EMACAddr;
     
270.         // Initialize EMAC module with given parameter
     
271.         while (EMAC_Init(&Emac_Config) == ERROR){
     
272.                 // Delay for a while then continue initializing EMAC module
     
273.                 for (i = 0x100000; i; i--);
     
274.         }
     
275.         // Enable all interrupt
     
276.         EMAC_IntCmd((EMAC_INT_RX_OVERRUN | EMAC_INT_RX_ERR | EMAC_INT_RX_FIN \
     
277.                         | EMAC_INT_RX_DONE | EMAC_INT_TX_UNDERRUN | EMAC_INT_TX_ERR \
     
278.                         | EMAC_INT_TX_FIN | EMAC_INT_TX_DONE), ENABLE);
     
279.         NVIC_SetPriority(ENET_IRQn, 0);
     
280.         NVIC_EnableIRQ(ENET_IRQn);
     
281. }
     
282. 
     
283. /*-------------------------MAIN FUNCTION------------------------------*/
     
284. /*********************************************************************//**
     
285. * @brief                c_entry: Main EMAC program body
     
286. * @param[in]        None
     
287. * @return                 int
     
288. **********************************************************************/
     
289. int c_entry (void)
     
290. {
     
291.         /* Data Packet format */
     
292.         EMAC_PACKETBUF_Type DataPacket;
     
293. 
     
294.         uint8_t *txptr;
     
295. 
     
296.         //uint32_t j;
     
297. 
     
298.         /*BOUNCE_RX*/
     
299.         uint8_t *rxptr;
     
300. 
     
301.         NVIC_SetPriorityGrouping(4);  //sets PRIGROUP to 3:2 (XXX:YY)
     
302. 
     
303.         // Init EMAC
     
304.         Usr_Init_Emac();
     
305. 
     
306.         //txptr = (uint8_t *)gTxBuf;
     
307.         /* pre-format the transmit packets */
     
308.         //PacketGen(txptr);
     
309. 
     
310.         /*BOUNCE_RX*/
     
311.         //copy just received data from RX buffer to TX buffer and send out
     
312.         txptr = (uint8_t *)gTxBuf;
     
313.         rxptr = (uint8_t *)gRxBuf;
     
314. 
     
315.         /*BOUNCE_RX*/
     
316.         while( 1 )
     
317.         {
     
318.                 //LED_Blink(BLINK_LED_PIN);
     
319.                 if ( PacketReceived == TRUE )
     
320.                 {
     
321.                           PacketReceived = FALSE;
     
322.                         //Reverse Source and Destination, then copy the body
     
323.                         memcpy( (uint8_t *)txptr, (uint8_t *)(rxptr+6), 6);
     
324.                         memcpy( (uint8_t *)(txptr+6), (uint8_t *)rxptr, 6);
     
325.                         memcpy( (uint8_t *)(txptr+12), (uint8_t *)(rxptr+12), (ReceiveLength - 12));
     
326.                         //Send packet back
     
327.                         DataPacket.pbDataBuf = (uint32_t *)txptr;
     
328.                         DataPacket.ulDataLen = ReceiveLength;
     
329.                         EMAC_WritePacketBuffer(&DataPacket);
     
330.                         EMAC_UpdateTxProduceIndex();
     
331.                 }
     
332.         }
     
333. 
     
334.         /* Transmit packets only */
     
335.         /*
     
336.         while ( 1 ) {
     
337.                 txptr = (uint8_t *)gTxBuf;
     
338.                 //_DBG_("Send packet");
     
339.                 //LED_Blink(TX_LED_PIN);
     
340.                 DataPacket.pbDataBuf = (uint32_t *)txptr;
     
341.                 // Note that there're 4-byte CRC added
     
342.                 DataPacket.ulDataLen = TX_PACKET_SIZE + 4;
     
343.                 EMAC_WritePacketBuffer(&DataPacket);
     
344.                 EMAC_UpdateTxProduceIndex();
     
345.                 for ( j = 0; j < 0x200000; j++ );        //delay
     
346.         }
     
347.         */
     
348. }
     
349. 
     
350. int main(void)
     
351. {
     
352.     return c_entry();
     
353. }

复制代码

2. lpc17xx_emac.c
这个文件我没有任何改动。

3. 用于发送以太网帧的linux程序pf_packet_sock.c
在附件中。

五、遇到的问题
用JLINK调试开发板，当网口接收到一个以太网帧时，就会进入ENET_IRQHandler中断处理程序，清中断、检查中断类型等等，直到进入第123行语句，发现总是跳转到rel，这说明出现了一个“EMAC_RINFO_SYM_ERR”错误。我查了数据手册，说是“SymbolError，在接收过程中，PHY通过PHY接口报告有一个位错误”。我不明白为什么会出现这种错误。实际上，我尝试过把“EMAC_CheckReceiveDataStatus(EMAC_RINFO_SYM_ERR)”注释，那么程序就接收正常，之后我再把接收到的数据包发送到我台式机，通过抓包，我发现，此时抓到的数据帧与我发送的数据帧一样。这又说明我接收的数据帧没有什么问题。但为什么报EMAC_RINFO_SYM_ERR错误呢？很困惑，迷茫，希望各位能给点提示，谢谢了。

zhongshu_1988

找到问题了，我用同样的程序测试刚焊接好的一块板卡，没问题，可以推断，问题出在微雪板卡或者DP83848以太网物理层芯片上。

wt-3333

请教个问题,lpc1768做以太网通信 - 可以正常通信,只是在大量数据包下网络会断(能发,但是不能接收)

liuzheng1992

zhongshu_1988 发表于 2013-1-16 15:24
找到问题了，我用同样的程序测试刚焊接好的一块板卡，没问题，可以推断，问题出在微雪板卡或者DP83848以太 ...

楼主，问一下arm的网口怎么连接啊，我就一个网线啊，是用一根网线把arm跟电脑相连吗

liu100149

能用吧

liu100149

有电路图没

zhengjunbo

这位兄弟，我也在用微雪的这个模块，也跟你发现同样的问题，你最后早到了产生SymbolError的原因了吗？