STM32L4R5板子模拟用户自定义的USB设备的问题

chenbingjy

我仿照圈圈的书，写了个模拟用户自定义的USB设备。
可以识别了，发送按键没有问题。
只是点灯不行。
中断处理函数如下：

1. #if defined (USB_OTG_FS)
   
2. /**
   
3.   * @brief  Handles PCD interrupt request.
   
4.   * [url=home.php?mod=space&uid=271674]@param[/url]  hpcd PCD handle
   
5.   * @retval HAL status
   
6.   */
   
7. void HAL_PCD_IRQHandler(PCD_HandleTypeDef *hpcd)
   
8. {
   
9.   USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
   
10.   uint32_t USBx_BASE = (uint32_t)USBx;
    
11.   USB_OTG_EPTypeDef *ep;
    
12.   uint32_t i;
    
13.   uint32_t ep_intr;
    
14.   uint32_t epint;
    
15.   uint32_t epnum;
    
16.   uint32_t fifoemptymsk;
    
17.   uint32_t RegVal;
    
18. 
    
19.        
    
20.   /* ensure that we are in device mode */
    
21.   if (USB_GetMode(hpcd->Instance) == USB_OTG_MODE_DEVICE)
    
22.   {
    
23.     /* avoid spurious interrupt */
    
24.     if (__HAL_PCD_IS_INVALID_INTERRUPT(hpcd))
    
25.     {
    
26.       return;
    
27.     }
    
28. 
    
29.     /* store current frame number */
    
30.     hpcd->FrameNumber = (USBx_DEVICE->DSTS & USB_OTG_DSTS_FNSOF_Msk) >> USB_OTG_DSTS_FNSOF_Pos;
    
31. 
    
32.     if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_MMIS))
    
33.     {
    
34.       /* incorrect mode, acknowledge the interrupt */
    
35.       __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_MMIS);
    
36.     }
    
37. 
    
38.     /* Handle RxQLevel Interrupt */
    
39.     if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_RXFLVL))
    
40.     {
    
41.       USB_MASK_INTERRUPT(hpcd->Instance, USB_OTG_GINTSTS_RXFLVL);
    
42. 
    
43.       RegVal = USBx->GRXSTSP;
    
44. 
    
45.       ep = &hpcd->OUT_ep[RegVal & USB_OTG_GRXSTSP_EPNUM];
    
46. 
    
47.       if (((RegVal & USB_OTG_GRXSTSP_PKTSTS) >> 17) ==  STS_DATA_UPDT)
    
48.       {
    
49.         if ((RegVal & USB_OTG_GRXSTSP_BCNT) != 0U)
    
50.         {
    
51.           (void)USB_ReadPacket(USBx, ep->xfer_buff,
    
52.                                (uint16_t)((RegVal & USB_OTG_GRXSTSP_BCNT) >> 4));
    
53.                        
    
54.                                        
    
55.                                        
    
56.           ep->xfer_buff += (RegVal & USB_OTG_GRXSTSP_BCNT) >> 4;
    
57.           ep->xfer_count += (RegVal & USB_OTG_GRXSTSP_BCNT) >> 4;
    
58.                                        
    
59.                                         //HAL_GPIO_WritePin(LD1_GPIO_Port, LD1_Pin, GPIO_PIN_SET);
    
60. 
    
61.         }
    
62.       }
    
63.       else if (((RegVal & USB_OTG_GRXSTSP_PKTSTS) >> 17) == STS_SETUP_UPDT)
    
64.       {
    
65.         (void)USB_ReadPacket(USBx, (uint8_t *)hpcd->Setup, 8U);
    
66.         ep->xfer_count += (RegVal & USB_OTG_GRXSTSP_BCNT) >> 4;
    
67. 
    
68.       }
    
69.       else
    
70.       {
    
71.         /* ... */
    
72.                                 //HAL_GPIO_WritePin(LD3_GPIO_Port, LD3_Pin, GPIO_PIN_SET);
    
73.       }
    
74. 
    
75.       USB_UNMASK_INTERRUPT(hpcd->Instance, USB_OTG_GINTSTS_RXFLVL);
    
76.     }
    
77. 
    
78.     if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_OEPINT))
    
79.     {
    
80.       epnum = 0U;
    
81. 
    
82.       /* Read in the device interrupt bits */
    
83.       ep_intr = USB_ReadDevAllOutEpInterrupt(hpcd->Instance);
    
84. 
    
85.       while (ep_intr != 0U)
    
86.       {
    
87.         if ((ep_intr & 0x1U) != 0U)
    
88.         {
    
89.           epint = USB_ReadDevOutEPInterrupt(hpcd->Instance, (uint8_t)epnum);
    
90.                                        
    
91.                                         //////////////////////////////////////////////////////////////////
    
92.        
    
93.           if ((epint & USB_OTG_DOEPINT_XFRC) == USB_OTG_DOEPINT_XFRC)
    
94.           {
    
95.             CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_XFRC);
    
96.             (void)PCD_EP_OutXfrComplete_int(hpcd, epnum);
    
97.           }
    
98. 
    
99.           if ((epint & USB_OTG_DOEPINT_STUP) == USB_OTG_DOEPINT_STUP)
    
100.           {
     
101.             CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_STUP);
     
102.             /* Class B setup phase done for previous decoded setup */
     
103.             (void)PCD_EP_OutSetupPacket_int(hpcd, epnum);
     
104.           }
     
105. 
     
106.           if ((epint & USB_OTG_DOEPINT_OTEPDIS) == USB_OTG_DOEPINT_OTEPDIS)
     
107.           {
     
108.             CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_OTEPDIS);
     
109.           }
     
110. 
     
111.           /* Clear OUT Endpoint disable interrupt */
     
112.           if ((epint & USB_OTG_DOEPINT_EPDISD) == USB_OTG_DOEPINT_EPDISD)
     
113.           {
     
114.             if ((USBx->GINTSTS & USB_OTG_GINTSTS_BOUTNAKEFF) == USB_OTG_GINTSTS_BOUTNAKEFF)
     
115.             {
     
116.               USBx_DEVICE->DCTL |= USB_OTG_DCTL_CGONAK;
     
117.             }
     
118. 
     
119.             ep = &hpcd->OUT_ep[epnum];
     
120. 
     
121.             if (ep->is_iso_incomplete == 1U)
     
122.             {
     
123.               ep->is_iso_incomplete = 0U;
     
124. 
     
125. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
     
126.               hpcd->ISOOUTIncompleteCallback(hpcd, (uint8_t)epnum);
     
127. #else
     
128.               HAL_PCD_ISOOUTIncompleteCallback(hpcd, (uint8_t)epnum);
     
129. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
     
130.             }
     
131. 
     
132.             CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_EPDISD);
     
133.           }
     
134. 
     
135.           /* Clear Status Phase Received interrupt */
     
136.           if ((epint & USB_OTG_DOEPINT_OTEPSPR) == USB_OTG_DOEPINT_OTEPSPR)
     
137.           {
     
138.             CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_OTEPSPR);
     
139.           }
     
140. 
     
141.           /* Clear OUT NAK interrupt */
     
142.           if ((epint & USB_OTG_DOEPINT_NAK) == USB_OTG_DOEPINT_NAK)
     
143.           {
     
144.             CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_NAK);
     
145.           }
     
146.         }
     
147.         epnum++;
     
148.         ep_intr >>= 1U;
     
149.       }
     
150.     }
     
151. 
     
152.     if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_IEPINT))
     
153.     {
     
154.       /* Read in the device interrupt bits */
     
155.       ep_intr = USB_ReadDevAllInEpInterrupt(hpcd->Instance);
     
156. 
     
157.       epnum = 0U;
     
158. 
     
159.       while (ep_intr != 0U)
     
160.       {
     
161.         if ((ep_intr & 0x1U) != 0U) /* In ITR */
     
162.         {
     
163.           epint = USB_ReadDevInEPInterrupt(hpcd->Instance, (uint8_t)epnum);
     
164. 
     
165.           if ((epint & USB_OTG_DIEPINT_XFRC) == USB_OTG_DIEPINT_XFRC)
     
166.           {
     
167.             fifoemptymsk = (uint32_t)(0x1UL << (epnum & EP_ADDR_MSK));
     
168.             USBx_DEVICE->DIEPEMPMSK &= ~fifoemptymsk;
     
169. 
     
170.             CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_XFRC);
     
171. 
     
172. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
     
173.             hpcd->DataInStageCallback(hpcd, (uint8_t)epnum);
     
174. #else
     
175.             HAL_PCD_DataInStageCallback(hpcd, (uint8_t)epnum);
     
176. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
     
177.           }
     
178.           if ((epint & USB_OTG_DIEPINT_TOC) == USB_OTG_DIEPINT_TOC)
     
179.           {
     
180.             CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_TOC);
     
181.           }
     
182.           if ((epint & USB_OTG_DIEPINT_ITTXFE) == USB_OTG_DIEPINT_ITTXFE)
     
183.           {
     
184.             CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_ITTXFE);
     
185.           }
     
186.           if ((epint & USB_OTG_DIEPINT_INEPNE) == USB_OTG_DIEPINT_INEPNE)
     
187.           {
     
188.             CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_INEPNE);
     
189.           }
     
190.           if ((epint & USB_OTG_DIEPINT_EPDISD) == USB_OTG_DIEPINT_EPDISD)
     
191.           {
     
192.             (void)USB_FlushTxFifo(USBx, epnum);
     
193. 
     
194.             ep = &hpcd->IN_ep[epnum];
     
195. 
     
196.             if (ep->is_iso_incomplete == 1U)
     
197.             {
     
198.               ep->is_iso_incomplete = 0U;
     
199. 
     
200. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
     
201.               hpcd->ISOINIncompleteCallback(hpcd, (uint8_t)epnum);
     
202. #else
     
203.               HAL_PCD_ISOINIncompleteCallback(hpcd, (uint8_t)epnum);
     
204. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
     
205.             }
     
206. 
     
207.             CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_EPDISD);
     
208.           }
     
209.           if ((epint & USB_OTG_DIEPINT_TXFE) == USB_OTG_DIEPINT_TXFE)
     
210.           {
     
211.             (void)PCD_WriteEmptyTxFifo(hpcd, epnum);
     
212.           }
     
213.         }
     
214.         epnum++;
     
215.         ep_intr >>= 1U;
     
216.       }
     
217.     }
     
218. 
     
219.     /* Handle Resume Interrupt */
     
220.     if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_WKUINT))
     
221.     {
     
222.       /* Clear the Remote Wake-up Signaling */
     
223.       USBx_DEVICE->DCTL &= ~USB_OTG_DCTL_RWUSIG;
     
224. 
     
225.       if (hpcd->LPM_State == LPM_L1)
     
226.       {
     
227.         hpcd->LPM_State = LPM_L0;
     
228. 
     
229. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
     
230.         hpcd->LPMCallback(hpcd, PCD_LPM_L0_ACTIVE);
     
231. #else
     
232.         HAL_PCDEx_LPM_Callback(hpcd, PCD_LPM_L0_ACTIVE);
     
233. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
     
234.       }
     
235.       else
     
236.       {
     
237. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
     
238.         hpcd->ResumeCallback(hpcd);
     
239. #else
     
240.         HAL_PCD_ResumeCallback(hpcd);
     
241. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
     
242.       }
     
243. 
     
244.       __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_WKUINT);
     
245.     }
     
246. 
     
247.     /* Handle Suspend Interrupt */
     
248.     if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_USBSUSP))
     
249.     {
     
250.       if ((USBx_DEVICE->DSTS & USB_OTG_DSTS_SUSPSTS) == USB_OTG_DSTS_SUSPSTS)
     
251.       {
     
252. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
     
253.         hpcd->SuspendCallback(hpcd);
     
254. #else
     
255.         HAL_PCD_SuspendCallback(hpcd);
     
256. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
     
257.       }
     
258.       __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_USBSUSP);
     
259.     }
     
260. 
     
261.     /* Handle LPM Interrupt */
     
262.     if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_LPMINT))
     
263.     {
     
264.       __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_LPMINT);
     
265. 
     
266.       if (hpcd->LPM_State == LPM_L0)
     
267.       {
     
268.         hpcd->LPM_State = LPM_L1;
     
269.         hpcd->BESL = (hpcd->Instance->GLPMCFG & USB_OTG_GLPMCFG_BESL) >> 2U;
     
270. 
     
271. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
     
272.         hpcd->LPMCallback(hpcd, PCD_LPM_L1_ACTIVE);
     
273. #else
     
274.         HAL_PCDEx_LPM_Callback(hpcd, PCD_LPM_L1_ACTIVE);
     
275. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
     
276.       }
     
277.       else
     
278.       {
     
279. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
     
280.         hpcd->SuspendCallback(hpcd);
     
281. #else
     
282.         HAL_PCD_SuspendCallback(hpcd);
     
283. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
     
284.       }
     
285.     }
     
286. 
     
287.     /* Handle Reset Interrupt */
     
288.     if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_USBRST))
     
289.     {
     
290.       USBx_DEVICE->DCTL &= ~USB_OTG_DCTL_RWUSIG;
     
291.       (void)USB_FlushTxFifo(hpcd->Instance, 0x10U);
     
292. 
     
293.       for (i = 0U; i < hpcd->Init.dev_endpoints; i++)
     
294.       {
     
295.         USBx_INEP(i)->DIEPINT = 0xFB7FU;
     
296.         USBx_INEP(i)->DIEPCTL &= ~USB_OTG_DIEPCTL_STALL;
     
297.         USBx_OUTEP(i)->DOEPINT = 0xFB7FU;
     
298.         USBx_OUTEP(i)->DOEPCTL &= ~USB_OTG_DOEPCTL_STALL;
     
299.         USBx_OUTEP(i)->DOEPCTL |= USB_OTG_DOEPCTL_SNAK;
     
300.       }
     
301.       USBx_DEVICE->DAINTMSK |= 0x10001U;
     
302. 
     
303.       if (hpcd->Init.use_dedicated_ep1 != 0U)
     
304.       {
     
305.         USBx_DEVICE->DOUTEP1MSK |= USB_OTG_DOEPMSK_STUPM |
     
306.                                    USB_OTG_DOEPMSK_XFRCM |
     
307.                                    USB_OTG_DOEPMSK_EPDM;
     
308. 
     
309.         USBx_DEVICE->DINEP1MSK |= USB_OTG_DIEPMSK_TOM |
     
310.                                   USB_OTG_DIEPMSK_XFRCM |
     
311.                                   USB_OTG_DIEPMSK_EPDM;
     
312.                                
     
313.        
     
314. 
     
315.       }
     
316.       else
     
317.       {
     
318.         USBx_DEVICE->DOEPMSK |= USB_OTG_DOEPMSK_STUPM |
     
319.                                 USB_OTG_DOEPMSK_XFRCM |
     
320.                                 USB_OTG_DOEPMSK_EPDM |
     
321.                                 USB_OTG_DOEPMSK_OTEPSPRM |
     
322.                                 USB_OTG_DOEPMSK_NAKM;
     
323. 
     
324.         USBx_DEVICE->DIEPMSK |= USB_OTG_DIEPMSK_TOM |
     
325.                                 USB_OTG_DIEPMSK_XFRCM |
     
326.                                 USB_OTG_DIEPMSK_EPDM;
     
327.       }
     
328. 
     
329.       /* Set Default Address to 0 */
     
330.       USBx_DEVICE->DCFG &= ~USB_OTG_DCFG_DAD;
     
331. 
     
332.       /* setup EP0 to receive SETUP packets */
     
333.       (void)USB_EP0_OutStart(hpcd->Instance, (uint8_t *)hpcd->Setup);
     
334. 
     
335.       __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_USBRST);
     
336.     }
     
337. 
     
338.     /* Handle Enumeration done Interrupt */
     
339.     if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_ENUMDNE))
     
340.     {
     
341.       (void)USB_ActivateSetup(hpcd->Instance);
     
342.       hpcd->Init.speed = USB_GetDevSpeed(hpcd->Instance);
     
343. 
     
344.       /* Set USB Turnaround time */
     
345.       (void)USB_SetTurnaroundTime(hpcd->Instance,
     
346.                                   HAL_RCC_GetHCLKFreq(),
     
347.                                   (uint8_t)hpcd->Init.speed);
     
348. 
     
349. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
     
350.       hpcd->ResetCallback(hpcd);
     
351. #else
     
352.       HAL_PCD_ResetCallback(hpcd);
     
353. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
     
354. 
     
355.       __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_ENUMDNE);
     
356.     }
     
357. 
     
358.     /* Handle SOF Interrupt */
     
359.     if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_SOF))
     
360.     {
     
361. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
     
362.       hpcd->SOFCallback(hpcd);
     
363. #else
     
364.       HAL_PCD_SOFCallback(hpcd);
     
365. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
     
366. 
     
367.       __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_SOF);
     
368.     }
     
369. 
     
370.     /* Handle Global OUT NAK effective Interrupt */
     
371.     if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_BOUTNAKEFF))
     
372.     {
     
373.       USBx->GINTMSK &= ~USB_OTG_GINTMSK_GONAKEFFM;
     
374. 
     
375.       for (epnum = 1U; epnum < hpcd->Init.dev_endpoints; epnum++)
     
376.       {
     
377.         if (hpcd->OUT_ep[epnum].is_iso_incomplete == 1U)
     
378.         {
     
379.           /* Abort current transaction and disable the EP */
     
380.           (void)HAL_PCD_EP_Abort(hpcd, (uint8_t)epnum);
     
381.         }
     
382.       }
     
383.     }
     
384. 
     
385.     /* Handle Incomplete ISO IN Interrupt */
     
386.     if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_IISOIXFR))
     
387.     {
     
388.       for (epnum = 1U; epnum < hpcd->Init.dev_endpoints; epnum++)
     
389.       {
     
390.         RegVal = USBx_INEP(epnum)->DIEPCTL;
     
391. 
     
392.         if ((hpcd->IN_ep[epnum].type == EP_TYPE_ISOC) &&
     
393.             ((RegVal & USB_OTG_DIEPCTL_EPENA) == USB_OTG_DIEPCTL_EPENA))
     
394.         {
     
395.           hpcd->IN_ep[epnum].is_iso_incomplete = 1U;
     
396. 
     
397.           /* Abort current transaction and disable the EP */
     
398.           (void)HAL_PCD_EP_Abort(hpcd, (uint8_t)(epnum | 0x80U));
     
399.         }
     
400.       }
     
401. 
     
402.       __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_IISOIXFR);
     
403.     }
     
404. 
     
405.     /* Handle Incomplete ISO OUT Interrupt */
     
406.     if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT))
     
407.     {
     
408.       for (epnum = 1U; epnum < hpcd->Init.dev_endpoints; epnum++)
     
409.       {
     
410.         RegVal = USBx_OUTEP(epnum)->DOEPCTL;
     
411. 
     
412.         if ((hpcd->OUT_ep[epnum].type == EP_TYPE_ISOC) &&
     
413.             ((RegVal & USB_OTG_DOEPCTL_EPENA) == USB_OTG_DOEPCTL_EPENA) &&
     
414.             ((RegVal & (0x1U << 16)) == (hpcd->FrameNumber & 0x1U)))
     
415.         {
     
416.           hpcd->OUT_ep[epnum].is_iso_incomplete = 1U;
     
417. 
     
418.           USBx->GINTMSK |= USB_OTG_GINTMSK_GONAKEFFM;
     
419. 
     
420.           if ((USBx->GINTSTS & USB_OTG_GINTSTS_BOUTNAKEFF) == 0U)
     
421.           {
     
422.             USBx_DEVICE->DCTL |= USB_OTG_DCTL_SGONAK;
     
423.             break;
     
424.           }
     
425.         }
     
426.       }
     
427. 
     
428.       __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT);
     
429.     }
     
430. 
     
431.     /* Handle Connection event Interrupt */
     
432.     if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_SRQINT))
     
433.     {
     
434. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
     
435.       hpcd->ConnectCallback(hpcd);
     
436. #else
     
437.       HAL_PCD_ConnectCallback(hpcd);
     
438. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
     
439. 
     
440.       __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_SRQINT);
     
441.     }
     
442. 
     
443.     /* Handle Disconnection event Interrupt */
     
444.     if (__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_OTGINT))
     
445.     {
     
446.       RegVal = hpcd->Instance->GOTGINT;
     
447. 
     
448.       if ((RegVal & USB_OTG_GOTGINT_SEDET) == USB_OTG_GOTGINT_SEDET)
     
449.       {
     
450. #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
     
451.         hpcd->DisconnectCallback(hpcd);
     
452. #else
     
453.         HAL_PCD_DisconnectCallback(hpcd);
     
454. #endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
     
455.       }
     
456.       hpcd->Instance->GOTGINT |= RegVal;
     
457.     }
     
458.   }
     
459. }
     
460. #endif /* defined (USB_OTG_FS) */

复制代码

我不知道该怎么接收数据，用bus hound也发不出数据来。
还有一点，圈圈的书上写着要用端点1输出。
hpcd_USB_OTG_FS.Init.use_dedicated_ep1 = DISABLE;
这个把端点一禁止了。可是我一使能它，设备就不识别。
高手支招，谢谢！