STM32

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

2019-12-16 22:37发布

站内问答 / STM32/STM8
3153 0 1
本帖最后由 zhongjp85 于 2018-10-26 10:20 编辑

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! ");
  19. //        printf("wait 5s NB Reset! ");

  21.     /* Configure the RTC */
  22.     RTC_Config();   
  23.    
  24.     while(1)
  25.     {
  26.         SystemClock_Config();
  27.         init();
  28.         printf("------- wake up -------- ");
  29.         LedOn(1);
  30.         HAL_Delay(5000);
  31.         LedOff(1);
  32.         HAL_Delay(5000);
  33.         
  34.         printf(" ------- sleep -------- ");
  35.         rtc_wakeup_cfg();      
  36.         SystemPower_Config();
  37.         HW_WakeupPinInit();
  38.         enter_stop_mode();
  39.     }
  40.    
  41. }

  43. void tasks(void)
  44. {  
  45.     bool isGoSleep = false;
  46.    
  47.     while(!isGoSleep)
  48.     {   
  49.         LedTask();
  50.         SensorTask();
  51.         isGoSleep = NB_Task();
  52.     }
  53. }

  55. void rtc_wakeup_cfg(void)
  56. {
  57.     /* Disable Wakeup Counter */
  58.     HAL_RTCEx_DeactivateWakeUpTimer(&RTCHandle);

  60.     HAL_RTCEx_SetWakeUpTimer_IT(&RTCHandle, RTC_TIME, RTC_WAKEUPCLOCK_CK_SPRE_16BITS);
  61. }

  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. }

  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();

  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. }

  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;

  103.     /**Configure the main internal regulator output voltage
  104.     */
  105.     __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

  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.     }

  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;

  130.     if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
  131.     {
  132.         _Error_Handler(__FILE__, __LINE__);
  133.     }

  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.     }

  143.     /**Configure the Systick interrupt time
  144.     */
  145.     HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);

  147.     /**Configure the Systick
  148.     */
  149.     HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);

  151.     /* SysTick_IRQn interrupt configuration */
  152.     HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);

  154. }

  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;

  171.     /* Enable Power Control clock */
  172.     __HAL_RCC_PWR_CLK_ENABLE();

  174.     /* Enable Ultra low power mode */
  175.     HAL_PWREx_EnableUltraLowPower();

  177.     /* Enable the fast wake up from Ultra low power mode */
  178.     HAL_PWREx_EnableFastWakeUp();

  180.     /* Select MSI as system clock source after Wake Up from Stop mode */
  181.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_MSI);

  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();

  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;

  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);

  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. }

  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. }


  241. void MX_GPIO_Init(void)
  242. {

  244.     GPIO_InitTypeDef GPIO_InitStruct;

  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();

  252.     GPIOA->MODER = 0xFFFFFFFF;
  253.     GPIOB->MODER = 0xFFFFFFFF;
  254.     GPIOC->MODER = 0xFFFFFFFF;
  255.     GPIOH->MODER = 0xFFFFFFFF;

  257.     /*Configure GPIO pin Output Level */
  258.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_RESET);

  260.     /*Configure GPIO pin Output Level */
  261.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4|GPIO_PIN_5, GPIO_PIN_SET);

  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);

  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);

  276.     __HAL_RCC_GPIOB_CLK_DISABLE();
  277.     __HAL_RCC_GPIOC_CLK_DISABLE();
  278.     __HAL_RCC_GPIOH_CLK_DISABLE();

  280.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
  281.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);

  283. }

  285. void MX_DMA_Init(void)
  286. {
  287.   /* DMA controller clock enable */
  288.   __HAL_RCC_DMA1_CLK_ENABLE();

  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);

  295. }



  299. /* LPUART1 init function */
  300. void MX_LPUART1_UART_Init(void)
  301. {

  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.     }

  317. }

  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

  339. }
  340. void HAL_UART_MspInit(UART_HandleTypeDef* huart)
  341. {

  343.   GPIO_InitTypeDef GPIO_InitStruct;
  344.   if(huart->Instance==LPUART1)
  345.   {
  346.   /* USER CODE BEGIN LPUART1_MspInit 0 */

  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);

  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.     }

  379.     __HAL_LINKDMA(huart,hdmarx,hdma_lpuart1_rx);

  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 */

  386.   /* USER CODE END LPUART1_MspInit 1 */
  387.   }
  388.   else if(huart->Instance==USART2)
  389.   {
  390.   /* USER CODE BEGIN USART2_MspInit 0 */

  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);

  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 */

  412.   /* USER CODE END USART2_MspInit 1 */
  413.   }

  415. }

  417. void HAL_UART_MspDeInit(UART_HandleTypeDef* huart)
  418. {

  420.   if(huart->Instance==LPUART1)
  421.   {
  422.   /* USER CODE BEGIN LPUART1_MspDeInit 0 */

  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);

  434.     /* LPUART1 DMA DeInit */
  435.     HAL_DMA_DeInit(huart->hdmarx);

  437.     /* LPUART1 interrupt DeInit */
  438.     HAL_NVIC_DisableIRQ(AES_RNG_LPUART1_IRQn);
  439.   /* USER CODE BEGIN LPUART1_MspDeInit 1 */

  441.   /* USER CODE END LPUART1_MspDeInit 1 */
  442.   }
  443.   else if(huart->Instance==USART2)
  444.   {
  445.   /* USER CODE BEGIN USART2_MspDeInit 0 */

  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);

  457.     /* USART2 interrupt DeInit */
  458.     HAL_NVIC_DisableIRQ(USART2_IRQn);
  459.   /* USER CODE BEGIN USART2_MspDeInit 1 */

  461.   /* USER CODE END USART2_MspDeInit 1 */
  462.   }

  464. }

  466. /* USER CODE BEGIN 1 */

  468. void EnableUartIT(void)//′??ú3?ê??ˉ
  469. {
  470.         //′??ú1
  471.     __HAL_UART_ENABLE_IT(&hlpuart1, UART_IT_IDLE);

  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);

  479.     HAL_UART_Receive_IT(&huart2, &Usart2Rx, 1);
  480. #endif
  481. }
复制代码
发送
 看不清?
0条回答

一周热门 更多>