STM32L031 stop模式恢复后串口无法使用

zhongjp85

STM32L031退出STOP模式后 串口无法使用  (不进入stop模式串口正常)

哪位能帮忙看下吗？ 谢谢！

主要代码如下 init()是初始化IO口的：

1. void test1(void)
   
2. {
   
3.   /* STM32L0xx HAL library initialization:
   
4.        - Configure the Flash prefetch, Flash preread and Buffer caches
   
5.        - Systick timer is configured by default as source of time base, but user
   
6.              can eventually implement his proper time base source (a general purpose
   
7.              timer for example or other time source), keeping in mind that Time base
   
8.              duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
   
9.              handled in milliseconds basis.
   
10.        - Low Level Initialization
    
11.      */
    
12.     HAL_Init();   
    
13.    
    
14.     /* Configure the system clock to 2 MHz */
    
15. //    SystemClock_Config();
    
16. //    init();
    
17. //   
    
18. //    printf("system is init ok!\r\n");
    
19. //        printf("wait 5s NB Reset!\r\n");
    
20. 
    
21.     /* Configure the RTC */
    
22.     RTC_Config();   
    
23.    
    
24.     while(1)
    
25.     {
    
26.         SystemClock_Config();
    
27.         init();
    
28.         printf("------- wake up --------\r\n");
    
29.         LedOn(1);
    
30.         HAL_Delay(5000);
    
31.         LedOff(1);
    
32.         HAL_Delay(5000);
    
33.         
    
34.         printf("\r\n------- sleep --------\r\n");
    
35.         rtc_wakeup_cfg();      
    
36.         SystemPower_Config();
    
37.         HW_WakeupPinInit();
    
38.         enter_stop_mode();
    
39.     }
    
40.    
    
41. }
    
42. 
    
43. void tasks(void)
    
44. {  
    
45.     bool isGoSleep = false;
    
46.    
    
47.     while(!isGoSleep)
    
48.     {   
    
49.         LedTask();
    
50.         SensorTask();
    
51.         isGoSleep = NB_Task();
    
52.     }
    
53. }
    
54. 
    
55. void rtc_wakeup_cfg(void)
    
56. {
    
57.     /* Disable Wakeup Counter */
    
58.     HAL_RTCEx_DeactivateWakeUpTimer(&RTCHandle);
    
59. 
    
60.     HAL_RTCEx_SetWakeUpTimer_IT(&RTCHandle, RTC_TIME, RTC_WAKEUPCLOCK_CK_SPRE_16BITS);
    
61. }
    
62. 
    
63. void enter_stop_mode(void)
    
64. {
    
65.     /* Enable Power Control clock */
    
66.     __HAL_RCC_PWR_CLK_ENABLE();
    
67.     /* Enter Stop Mode */
    
68.     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
69. }
    
70. 
    
71. void HW_WakeupPinInit(void)
    
72. {   
    
73.     GPIO_InitTypeDef GPIO_InitStruct;
    
74.     /* Configure PB.1 as input with External interrupt */
    
75.     GPIO_InitStruct.Pin = GPIO_PIN_6 | GPIO_PIN_7;
    
76.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
77.     GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
    
78.    
    
79.     /* Enable GPIOA clock */
    
80.     __HAL_RCC_GPIOA_CLK_ENABLE();
    
81. 
    
82.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
83.    
    
84.     GPIO_InitStruct.Pin = GPIO_PIN_13 | GPIO_PIN_14;
    
85.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
86.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
    
87.    
    
88.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);   
    
89.    
    
90.     /* Enable and set PA.12 (Arduino D2) EXTI Interrupt to the lowest priority */
    
91.     NVIC_SetPriority((IRQn_Type)(EXTI4_15_IRQn), 0x03);
    
92.     HAL_NVIC_EnableIRQ((IRQn_Type)(EXTI4_15_IRQn));
    
93. }
    
94. 
    
95. /** System Clock Configuration
    
96. */
    
97. void SystemClock_Config(void)
    
98. {
    
99.     RCC_OscInitTypeDef RCC_OscInitStruct;
    
100.     RCC_ClkInitTypeDef RCC_ClkInitStruct;
     
101.     RCC_PeriphCLKInitTypeDef PeriphClkInit;
     
102. 
     
103.     /**Configure the main internal regulator output voltage
     
104.     */
     
105.     __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
     
106. 
     
107.     /**Initializes the CPU, AHB and APB busses clocks
     
108.     */
     
109.     RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
     
110.     RCC_OscInitStruct.HSIState = RCC_HSI_ON;
     
111.     RCC_OscInitStruct.HSICalibrationValue = 16;
     
112.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
     
113.     RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
     
114.     RCC_OscInitStruct.PLL.PLLMUL = RCC_PLLMUL_4;
     
115.     RCC_OscInitStruct.PLL.PLLDIV = RCC_PLLDIV_2;
     
116.     if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
     
117.     {
     
118.         _Error_Handler(__FILE__, __LINE__);
     
119.     }
     
120. 
     
121.     /**Initializes the CPU, AHB and APB busses clocks
     
122.     */
     
123.     RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
     
124.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
     
125.     RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
     
126.     RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
     
127.     RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
     
128.     RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
     
129. 
     
130.     if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
     
131.     {
     
132.         _Error_Handler(__FILE__, __LINE__);
     
133.     }
     
134. 
     
135.     PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART2|RCC_PERIPHCLK_LPUART1;
     
136.     PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_PCLK1;
     
137.     PeriphClkInit.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_PCLK1;
     
138.     if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
     
139.     {
     
140.         _Error_Handler(__FILE__, __LINE__);
     
141.     }
     
142. 
     
143.     /**Configure the Systick interrupt time
     
144.     */
     
145.     HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);
     
146. 
     
147.     /**Configure the Systick
     
148.     */
     
149.     HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
     
150. 
     
151.     /* SysTick_IRQn interrupt configuration */
     
152.     HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
     
153. 
     
154. }
     
155. 
     
156. /**
     
157.   * @brief  System Power Configuration
     
158.   *         The system Power is configured as follow :
     
159.   *            + Regulator in LP mode
     
160.   *            + VREFINT OFF, with fast wakeup enabled
     
161.   *            + MSI as SysClk after Wake Up
     
162.   *            + No IWDG
     
163.   *            + Wakeup using EXTI Line (User push-button PC.13)
     
164.   * @param  None
     
165.   * @retval None
     
166.   */
     
167. static void SystemPower_Config(void)
     
168. {
     
169.     GPIO_InitTypeDef GPIO_InitStructure;
     
170. 
     
171.     /* Enable Power Control clock */
     
172.     __HAL_RCC_PWR_CLK_ENABLE();
     
173. 
     
174.     /* Enable Ultra low power mode */
     
175.     HAL_PWREx_EnableUltraLowPower();
     
176. 
     
177.     /* Enable the fast wake up from Ultra low power mode */
     
178.     HAL_PWREx_EnableFastWakeUp();
     
179. 
     
180.     /* Select MSI as system clock source after Wake Up from Stop mode */
     
181.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_MSI);
     
182. 
     
183.     /* Enable GPIOs clock */
     
184.     __HAL_RCC_GPIOA_CLK_ENABLE();
     
185.     __HAL_RCC_GPIOB_CLK_ENABLE();
     
186.     __HAL_RCC_GPIOC_CLK_ENABLE();
     
187.     __HAL_RCC_GPIOH_CLK_ENABLE();
     
188. 
     
189.     /* Configure all GPIO port pins in Analog Input mode (floating input trigger OFF) */
     
190.     /* Note: Debug using ST-Link is not possible during the execution of this   */
     
191.     /*       example because communication between ST-link and the device       */
     
192.     /*       under test is done through UART. All GPIO pins are disabled (set   */
     
193.     /*       to analog input mode) including  UART I/O pins.           */
     
194.     GPIO_InitStructure.Pin = GPIO_PIN_All;
     
195.     GPIO_InitStructure.Mode = GPIO_MODE_ANALOG;
     
196.     GPIO_InitStructure.Pull = GPIO_NOPULL;
     
197. 
     
198.     HAL_GPIO_Init(GPIOA, &GPIO_InitStructure);
     
199.     HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
     
200.     HAL_GPIO_Init(GPIOC, &GPIO_InitStructure);
     
201.     HAL_GPIO_Init(GPIOH, &GPIO_InitStructure);
     
202. 
     
203.     /* Disable GPIOs clock */
     
204.     __HAL_RCC_GPIOA_CLK_DISABLE();
     
205.     __HAL_RCC_GPIOB_CLK_DISABLE();
     
206.     __HAL_RCC_GPIOC_CLK_DISABLE();
     
207.     __HAL_RCC_GPIOH_CLK_DISABLE();
     
208. }
     
209. 
     
210. /**
     
211.   * @brief  RTC Configuration
     
212.   *         RTC Clocked by LSI (see HAL_RTC_MspInit)
     
213.   * @param  None
     
214.   * @retval None
     
215.   */
     
216. static void RTC_Config(void)
     
217. {
     
218.   /* Configure RTC */
     
219.   RTCHandle.Instance = RTC;
     
220.   /* Configure RTC prescaler and RTC data registers as follow:
     
221.     - Hour Format = Format 24
     
222.     - Asynch Prediv = Value according to source clock
     
223.     - Synch Prediv = Value according to source clock
     
224.     - OutPut = Output Disable
     
225.     - OutPutPolarity = High Polarity
     
226.     - OutPutType = Open Drain */
     
227.   RTCHandle.Init.HourFormat = RTC_HOURFORMAT_24;
     
228.   RTCHandle.Init.AsynchPrediv = RTC_ASYNCH_PREDIV;
     
229.   RTCHandle.Init.SynchPrediv = RTC_SYNCH_PREDIV;
     
230.   RTCHandle.Init.OutPut = RTC_OUTPUT_DISABLE;
     
231.   RTCHandle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
     
232.   RTCHandle.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
     
233.   if(HAL_RTC_Init(&RTCHandle) != HAL_OK)
     
234.   {
     
235.     /* Initialization Error */
     
236.     Error_Handler();
     
237.   }
     
238. }
     
239. 
     
240. 
     
241. void MX_GPIO_Init(void)
     
242. {
     
243. 
     
244.     GPIO_InitTypeDef GPIO_InitStruct;
     
245. 
     
246.     /* GPIO Ports Clock Enable */
     
247.     __HAL_RCC_GPIOA_CLK_ENABLE();
     
248.     __HAL_RCC_GPIOB_CLK_ENABLE();
     
249.     __HAL_RCC_GPIOC_CLK_ENABLE();
     
250.     __HAL_RCC_GPIOH_CLK_ENABLE();
     
251. 
     
252.     GPIOA->MODER = 0xFFFFFFFF;
     
253.     GPIOB->MODER = 0xFFFFFFFF;
     
254.     GPIOC->MODER = 0xFFFFFFFF;
     
255.     GPIOH->MODER = 0xFFFFFFFF;
     
256. 
     
257.     /*Configure GPIO pin Output Level */
     
258.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_RESET);
     
259. 
     
260.     /*Configure GPIO pin Output Level */
     
261.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4|GPIO_PIN_5, GPIO_PIN_SET);
     
262. 
     
263.     /*Configure GPIO pins : PA1 PA4 PA5 */
     
264.     GPIO_InitStruct.Pin = GPIO_PIN_1|GPIO_PIN_4|GPIO_PIN_5;
     
265.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
     
266.     GPIO_InitStruct.Pull = GPIO_NOPULL;
     
267.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
     
268.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
     
269. 
     
270.     /*Configure GPIO pin : PA7 PA6*/
     
271.     GPIO_InitStruct.Pin = GPIO_PIN_7|GPIO_PIN_6;
     
272.     GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
     
273.     GPIO_InitStruct.Pull = GPIO_PULLDOWN;
     
274.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
     
275. 
     
276.     __HAL_RCC_GPIOB_CLK_DISABLE();
     
277.     __HAL_RCC_GPIOC_CLK_DISABLE();
     
278.     __HAL_RCC_GPIOH_CLK_DISABLE();
     
279. 
     
280.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
     
281.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
     
282. 
     
283. }
     
284. 
     
285. void MX_DMA_Init(void)
     
286. {
     
287.   /* DMA controller clock enable */
     
288.   __HAL_RCC_DMA1_CLK_ENABLE();
     
289. 
     
290.   /* DMA interrupt init */
     
291.   /* DMA1_Channel2_3_IRQn interrupt configuration */
     
292.   HAL_NVIC_SetPriority(DMA1_Channel2_3_IRQn, 0, 0);
     
293.   HAL_NVIC_EnableIRQ(DMA1_Channel2_3_IRQn);
     
294. 
     
295. }
     
296. 
     
297. 
     
298. 
     
299. /* LPUART1 init function */
     
300. void MX_LPUART1_UART_Init(void)
     
301. {
     
302. 
     
303.     hlpuart1.Instance = LPUART1;
     
304.     hlpuart1.Init.BaudRate = 115200;
     
305.     hlpuart1.Init.WordLength = UART_WORDLENGTH_8B;
     
306.     hlpuart1.Init.StopBits = UART_STOPBITS_1;
     
307.     hlpuart1.Init.Parity = UART_PARITY_NONE;
     
308.     hlpuart1.Init.Mode = UART_MODE_TX_RX;
     
309.     hlpuart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
     
310.     hlpuart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
     
311.     hlpuart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
     
312.     if (HAL_UART_Init(&hlpuart1) != HAL_OK)
     
313.     {
     
314.         _Error_Handler(__FILE__, __LINE__);
     
315.     }
     
316. 
     
317. }
     
318. 
     
319. /* USART2 init function */
     
320. void MX_USART2_UART_Init(void)
     
321. {
     
322. #if DEBUG
     
323.     huart2.Instance = USART2;
     
324.     huart2.Init.BaudRate = 115200;
     
325.     huart2.Init.WordLength = UART_WORDLENGTH_8B;
     
326.     huart2.Init.StopBits = UART_STOPBITS_1;
     
327.     huart2.Init.Parity = UART_PARITY_NONE;
     
328.     huart2.Init.Mode = UART_MODE_TX_RX;
     
329.     huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
     
330.     huart2.Init.OverSampling = UART_OVERSAMPLING_16;
     
331.     huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
     
332.     huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
     
333.     if (HAL_UART_Init(&huart2) != HAL_OK)
     
334.     {
     
335.         _Error_Handler(__FILE__, __LINE__);
     
336.     }
     
337. #endif
     
338. 
     
339. }
     
340. void HAL_UART_MspInit(UART_HandleTypeDef* huart)
     
341. {
     
342. 
     
343.   GPIO_InitTypeDef GPIO_InitStruct;
     
344.   if(huart->Instance==LPUART1)
     
345.   {
     
346.   /* USER CODE BEGIN LPUART1_MspInit 0 */
     
347. 
     
348.   /* USER CODE END LPUART1_MspInit 0 */
     
349.     /* Peripheral clock enable */
     
350.     __HAL_RCC_LPUART1_CLK_ENABLE();
     
351.   
     
352.     /**LPUART1 GPIO Configuration   
     
353.     PA2     ------> LPUART1_TX
     
354.     PA3     ------> LPUART1_RX
     
355.     */
     
356.     GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;
     
357.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
     
358.     GPIO_InitStruct.Pull = GPIO_PULLUP;
     
359.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
     
360.     GPIO_InitStruct.Alternate = GPIO_AF6_LPUART1;
     
361.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
     
362. 
     
363.     /* LPUART1 DMA Init */
     
364.     /* LPUART1_RX Init */
     
365.     hdma_lpuart1_rx.Instance = DMA1_Channel3;
     
366.     hdma_lpuart1_rx.Init.Request = DMA_REQUEST_5;
     
367.     hdma_lpuart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
     
368.     hdma_lpuart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
     
369.     hdma_lpuart1_rx.Init.MemInc = DMA_MINC_ENABLE;
     
370.     hdma_lpuart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
     
371.     hdma_lpuart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
     
372.     hdma_lpuart1_rx.Init.Mode = DMA_NORMAL;
     
373.     hdma_lpuart1_rx.Init.Priority = DMA_PRIORITY_LOW;
     
374.     if (HAL_DMA_Init(&hdma_lpuart1_rx) != HAL_OK)
     
375.     {
     
376.       _Error_Handler(__FILE__, __LINE__);
     
377.     }
     
378. 
     
379.     __HAL_LINKDMA(huart,hdmarx,hdma_lpuart1_rx);
     
380. 
     
381.     /* LPUART1 interrupt Init */
     
382.     HAL_NVIC_SetPriority(AES_RNG_LPUART1_IRQn, 0, 0);
     
383.     HAL_NVIC_EnableIRQ(AES_RNG_LPUART1_IRQn);
     
384.   /* USER CODE BEGIN LPUART1_MspInit 1 */
     
385. 
     
386.   /* USER CODE END LPUART1_MspInit 1 */
     
387.   }
     
388.   else if(huart->Instance==USART2)
     
389.   {
     
390.   /* USER CODE BEGIN USART2_MspInit 0 */
     
391. 
     
392.   /* USER CODE END USART2_MspInit 0 */
     
393.     /* Peripheral clock enable */
     
394.     __HAL_RCC_USART2_CLK_ENABLE();
     
395.   
     
396.     /**USART2 GPIO Configuration   
     
397.     PA9     ------> USART2_TX
     
398.     PA10     ------> USART2_RX
     
399.     */
     
400.     GPIO_InitStruct.Pin = GPIO_PIN_9|GPIO_PIN_10;
     
401.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
     
402.     GPIO_InitStruct.Pull = GPIO_PULLUP;
     
403.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
     
404.     GPIO_InitStruct.Alternate = GPIO_AF4_USART2;
     
405.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
     
406. 
     
407.     /* USART2 interrupt Init */
     
408.     HAL_NVIC_SetPriority(USART2_IRQn, 0, 0);
     
409.     HAL_NVIC_EnableIRQ(USART2_IRQn);
     
410.   /* USER CODE BEGIN USART2_MspInit 1 */
     
411. 
     
412.   /* USER CODE END USART2_MspInit 1 */
     
413.   }
     
414. 
     
415. }
     
416. 
     
417. void HAL_UART_MspDeInit(UART_HandleTypeDef* huart)
     
418. {
     
419. 
     
420.   if(huart->Instance==LPUART1)
     
421.   {
     
422.   /* USER CODE BEGIN LPUART1_MspDeInit 0 */
     
423. 
     
424.   /* USER CODE END LPUART1_MspDeInit 0 */
     
425.     /* Peripheral clock disable */
     
426.     __HAL_RCC_LPUART1_CLK_DISABLE();
     
427.   
     
428.     /**LPUART1 GPIO Configuration   
     
429.     PA2     ------> LPUART1_TX
     
430.     PA3     ------> LPUART1_RX
     
431.     */
     
432.     HAL_GPIO_DeInit(GPIOA, GPIO_PIN_2|GPIO_PIN_3);
     
433. 
     
434.     /* LPUART1 DMA DeInit */
     
435.     HAL_DMA_DeInit(huart->hdmarx);
     
436. 
     
437.     /* LPUART1 interrupt DeInit */
     
438.     HAL_NVIC_DisableIRQ(AES_RNG_LPUART1_IRQn);
     
439.   /* USER CODE BEGIN LPUART1_MspDeInit 1 */
     
440. 
     
441.   /* USER CODE END LPUART1_MspDeInit 1 */
     
442.   }
     
443.   else if(huart->Instance==USART2)
     
444.   {
     
445.   /* USER CODE BEGIN USART2_MspDeInit 0 */
     
446. 
     
447.   /* USER CODE END USART2_MspDeInit 0 */
     
448.     /* Peripheral clock disable */
     
449.     __HAL_RCC_USART2_CLK_DISABLE();
     
450.   
     
451.     /**USART2 GPIO Configuration   
     
452.     PA9     ------> USART2_TX
     
453.     PA10     ------> USART2_RX
     
454.     */
     
455.     HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9|GPIO_PIN_10);
     
456. 
     
457.     /* USART2 interrupt DeInit */
     
458.     HAL_NVIC_DisableIRQ(USART2_IRQn);
     
459.   /* USER CODE BEGIN USART2_MspDeInit 1 */
     
460. 
     
461.   /* USER CODE END USART2_MspDeInit 1 */
     
462.   }
     
463. 
     
464. }
     
465. 
     
466. /* USER CODE BEGIN 1 */
     
467. 
     
468. void EnableUartIT(void)//′??ú3?ê??ˉ
     
469. {
     
470.         //′??ú1
     
471.     __HAL_UART_ENABLE_IT(&hlpuart1, UART_IT_IDLE);
     
472. 
     
473.     __HAL_UART_CLEAR_IDLEFLAG(&hlpuart1);
     
474.     HAL_UART_Receive_DMA(&hlpuart1,LPUart1type.LPUart1DMARecBuff,LPUART1_DMA_REC_SIZE);
     
475. #if DEBUG
     
476.     //′??ú2
     
477.     __HAL_UART_ENABLE_IT(&huart2, UART_IT_RXNE);
     
478. 
     
479.     HAL_UART_Receive_IT(&huart2, &Usart2Rx, 1);
     
480. #endif
     
481. }
     

复制代码