Change LPUART clock from LSE to HSI after wake up from STOP2

[matteverze]

Hi, I'm using an STM32WL5MOC where the LPUART is used to wake up the module from Stop2 mode. Since I have a lot of data to transfer, I would like to ask how I can switch to the HSI clock after waking up, and then, of course, switch back to the LSE to allow wake-up functionality.

Thanks.

[TDK]

>  I would like to ask how I can switch to the HSI clock after waking up, and then, of course, switch back to the LSE to allow wake-up functionality.

After exiting Stop 2 mode, the clock is either already on HSI or MSI depending on settings.

To switch from those to LSE, configure LSE as the system clock using HAL_RCC_OscConfig same as you do if you select it during startup.

[matteverze]

Hi  @TDK ,

Thank you for the reply. Do you mean that if I select the LSE clock in the clock tree diagram for the LPUART, it gets replaced by the HSI after waking up from STOP2 mode?

 

[TDK]

Ahh, you are asking about the LPUART clock, not the system clock.

LPUART1 can be clocked from LSE in stop2 mode. There are no changes. When it wakes up, it will still be clocked by that clock. If you want to switch it to a different clock, you will need to de-initialize it and re-initialize it with those settings. This has nothing to do with stop 2 mode.

[Chris21]

Presumably you would:

  DeInit the LPUART (or at least disable reception)

  Change the LPUART clock (RCC_CCIPR LPUART1SEL bits)

  Reinitialize the LPUART for desired baud rate

  Enable LPUART reception

Once you have learned the details for these steps, it should be clear how to reverse them (to go back to using the LSE as LPUART clock).

[matteverze]

Hi @TDK,

thanks. Do you have some example code to share on how I can de-initialize and re-initialize with HSI clock settings?

Thanks

[TDK]

Use CubeMX to generate initialization code for each scenario.

[matteverze]

hi @TDK ,

Should I copy all of this:

void MX_LPUART1_UART_Init(void)
{

 /* USER CODE BEGIN LPUART1_Init 0 */

 /* USER CODE END LPUART1_Init 0 */

 /* USER CODE BEGIN LPUART1_Init 1 */

 /* USER CODE END LPUART1_Init 1 */
 hlpuart1.Instance = LPUART1;
 hlpuart1.Init.BaudRate = 2400;
 hlpuart1.Init.WordLength = UART_WORDLENGTH_8B;
 hlpuart1.Init.StopBits = UART_STOPBITS_1;
 hlpuart1.Init.Parity = UART_PARITY_NONE;
 hlpuart1.Init.Mode = UART_MODE_TX_RX;
 hlpuart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
 hlpuart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
 hlpuart1.Init.ClockPrescaler = UART_PRESCALER_DIV1;
 hlpuart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
 hlpuart1.FifoMode = UART_FIFOMODE_DISABLE;
 if (HAL_UART_Init(&hlpuart1) != HAL_OK)
 {
 Error_Handler();
 }
 if (HAL_UARTEx_SetTxFifoThreshold(&hlpuart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
 {
 Error_Handler();
 }
 if (HAL_UARTEx_SetRxFifoThreshold(&hlpuart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
 {
 Error_Handler();
 }
 if (HAL_UARTEx_DisableFifoMode(&hlpuart1) != HAL_OK)
 {
 Error_Handler();
 }
 /* USER CODE BEGIN LPUART1_Init 2 */

 /* USER CODE END LPUART1_Init 2 */

}
/* USART1 init function */

And this:

 

void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
{

 GPIO_InitTypeDef GPIO_InitStruct = {0};
 RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
 if(uartHandle->Instance==LPUART1)
 {
 /* USER CODE BEGIN LPUART1_MspInit 0 */

 /* USER CODE END LPUART1_MspInit 0 */

 /** Initializes the peripherals clocks
 */
 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
 PeriphClkInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_LSE;
 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
 {
 Error_Handler();
 }

 /* LPUART1 clock enable */
 __HAL_RCC_LPUART1_CLK_ENABLE();

 __HAL_RCC_GPIOA_CLK_ENABLE();
 /**LPUART1 GPIO Configuration
 PA3 ------> LPUART1_RX
 PA2 ------> LPUART1_TX
 */
 GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_2;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 GPIO_InitStruct.Alternate = GPIO_AF8_LPUART1;
 HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

 /* LPUART1 DMA Init */
 /* LPUART1_RX Init */
 hdma_lpuart1_rx.Instance = DMA1_Channel2;
 hdma_lpuart1_rx.Init.Request = DMA_REQUEST_LPUART1_RX;
 hdma_lpuart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
 hdma_lpuart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
 hdma_lpuart1_rx.Init.MemInc = DMA_MINC_ENABLE;
 hdma_lpuart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
 hdma_lpuart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
 hdma_lpuart1_rx.Init.Mode = DMA_NORMAL;
 hdma_lpuart1_rx.Init.Priority = DMA_PRIORITY_LOW;
 if (HAL_DMA_Init(&hdma_lpuart1_rx) != HAL_OK)
 {
 Error_Handler();
 }

 if (HAL_DMA_ConfigChannelAttributes(&hdma_lpuart1_rx, DMA_CHANNEL_NPRIV) != HAL_OK)
 {
 Error_Handler();
 }

 __HAL_LINKDMA(uartHandle,hdmarx,hdma_lpuart1_rx);

 /* LPUART1_TX Init */
 hdma_lpuart1_tx.Instance = DMA1_Channel3;
 hdma_lpuart1_tx.Init.Request = DMA_REQUEST_LPUART1_TX;
 hdma_lpuart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
 hdma_lpuart1_tx.Init.PeriphInc = DMA_PINC_DISABLE;
 hdma_lpuart1_tx.Init.MemInc = DMA_MINC_ENABLE;
 hdma_lpuart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
 hdma_lpuart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
 hdma_lpuart1_tx.Init.Mode = DMA_NORMAL;
 hdma_lpuart1_tx.Init.Priority = DMA_PRIORITY_LOW;
 if (HAL_DMA_Init(&hdma_lpuart1_tx) != HAL_OK)
 {
 Error_Handler();
 }

 if (HAL_DMA_ConfigChannelAttributes(&hdma_lpuart1_tx, DMA_CHANNEL_NPRIV) != HAL_OK)
 {
 Error_Handler();
 }

 __HAL_LINKDMA(uartHandle,hdmatx,hdma_lpuart1_tx);

 /* LPUART1 interrupt Init */
 HAL_NVIC_SetPriority(LPUART1_IRQn, 2, 0);
 HAL_NVIC_EnableIRQ(LPUART1_IRQn);
 /* USER CODE BEGIN LPUART1_MspInit 1 */

 /* USER CODE END LPUART1_MspInit 1 */
 }