How to set an alarm in RTC to wakeup the MCU from the stop mode by using RTC alarm for every 5 minutes in STM32L4Rxx MCU?

[Shilpashree Madhu]

Actually the RTC alarm I've set isn't coming out exactly. It triggers only once, after that it'll keep getting triggered for every one minute. How to do it for every X minutes?

[Peter BENSCH]

Welcome, @Shilpashree Madhu​, to the community!

Unfortunately, you did not show us your settings for the RTC.

Anyway, you either:

• have to set the alarm to the next time each time you wake up (depending on the time difference, possibly a quite complex calculation, especially at the end of the day)
• or (probably easier) use the periodic wake-up (RM0432, section 46.3.6).

Regards

/Peter

[Shilpashree Madhu]

Thanks @Peter BENSCH​ , much appriciated.

As you said, I checked it using wakeup timer. But unfortunately it's still the same. I'm not able to get output for 2 minutes.

Should I change anything in this?

/* USER CODE BEGIN Header */
/**
 ******************************************************************************
 * @file : main.c
 * @brief : Main program body
 ******************************************************************************
 * @attention
 *
 * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
 * All rights reserved.</center></h2>
 *
 * This software component is licensed by ST under BSD 3-Clause license,
 * the "License"; You may not use this file except in compliance with the
 * License. You may obtain a copy of the License at:
 * opensource.org/licenses/BSD-3-Clause
 *
 ******************************************************************************
 */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
 
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
 
/* USER CODE END Includes */
 
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
 
/* USER CODE END PTD */
 
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */
 
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
 
/* USER CODE END PM */
 
/* Private variables ---------------------------------------------------------*/
RTC_HandleTypeDef hrtc;
 
/* USER CODE BEGIN PV */
 
/* USER CODE END PV */
 
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_RTC_Init(void);
/* USER CODE BEGIN PFP */
 
/* USER CODE END PFP */
 
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
 
/* USER CODE END 0 */
 
/**
 * @brief The application entry point.
 * @retval int
 */
int main(void)
{
 /* USER CODE BEGIN 1 */
 
 /* USER CODE END 1 */
 
 /* MCU Configuration--------------------------------------------------------*/
 
 /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
 HAL_Init();
 
 /* USER CODE BEGIN Init */
 
 /* USER CODE END Init */
 
 /* Configure the system clock */
 SystemClock_Config();
 
 /* USER CODE BEGIN SysInit */
 
 /* USER CODE END SysInit */
 
 /* Initialize all configured peripherals */
 MX_GPIO_Init();
 MX_RTC_Init();
 /* USER CODE BEGIN 2 */
 
 /* USER CODE END 2 */
 
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
 /* USER CODE END WHILE */
 HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7, GPIO_PIN_SET);
 HAL_Delay(1000);
 HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7, GPIO_PIN_RESET);
 HAL_SuspendTick();
 HAL_RTCEx_SetWakeUpTimer_IT(&hrtc,0x3C08D, RTC_WAKEUPCLOCK_CK_SPRE_17BITS);
 /* Enter STOP 2 mode */
 HAL_PWREx_EnterSTOP2Mode(PWR_STOPENTRY_WFI);
 HAL_RTCEx_DeactivateWakeUpTimer(&hrtc);
 SystemClock_Config();
 HAL_ResumeTick();
 /* USER CODE BEGIN 3 */
 }
 /* USER CODE END 3 */
}
 
/**
 * @brief System Clock Configuration
 * @retval None
 */
void SystemClock_Config(void)
{
 RCC_OscInitTypeDef RCC_OscInitStruct = {0};
 RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
 RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
 
 /** Configure the main internal regulator output voltage
 */
 if (HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1) != HAL_OK)
 {
 Error_Handler();
 }
 /** Configure LSE Drive Capability
 */
 HAL_PWR_EnableBkUpAccess();
 __HAL_RCC_LSEDRIVE_CONFIG(RCC_LSEDRIVE_LOW);
 /** Initializes the RCC Oscillators according to the specified parameters
 * in the RCC_OscInitTypeDef structure.
 */
 RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE|RCC_OSCILLATORTYPE_MSI;
 RCC_OscInitStruct.LSEState = RCC_LSE_ON;
 RCC_OscInitStruct.MSIState = RCC_MSI_ON;
 RCC_OscInitStruct.MSICalibrationValue = 0;
 RCC_OscInitStruct.MSIClockRange = RCC_MSIRANGE_8;
 RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
 if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
 {
 Error_Handler();
 }
 /** Initializes the CPU, AHB and APB buses clocks
 */
 RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
 |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
 RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_MSI;
 RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
 RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
 RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
 
 if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
 {
 Error_Handler();
 }
 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_RTC;
 PeriphClkInit.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
 {
 Error_Handler();
 }
}
 
/**
 * @brief RTC Initialization Function
 * @param None
 * @retval None
 */
static void MX_RTC_Init(void)
{
 
 /* USER CODE BEGIN RTC_Init 0 */
 
 /* USER CODE END RTC_Init 0 */
 
 /* USER CODE BEGIN RTC_Init 1 */
 
 /* USER CODE END RTC_Init 1 */
 /** Initialize RTC Only
 */
 hrtc.Instance = RTC;
 hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
 hrtc.Init.AsynchPrediv = 127;
 hrtc.Init.SynchPrediv = 255;
 hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
 hrtc.Init.OutPutRemap = RTC_OUTPUT_REMAP_NONE;
 hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
 hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
 if (HAL_RTC_Init(&hrtc) != HAL_OK)
 {
 Error_Handler();
 }
 /** Enable the WakeUp
 */
// if (HAL_RTCEx_SetWakeUpTimer_IT(&hrtc, 0x500B, RTC_WAKEUPCLOCK_RTCCLK_DIV16) != HAL_OK)
// {
// Error_Handler();
// }
 /* USER CODE BEGIN RTC_Init 2 */
 
 /* USER CODE END RTC_Init 2 */
 
}
 
/**
 * @brief GPIO Initialization Function
 * @param None
 * @retval None
 */
static void MX_GPIO_Init(void)
{
 GPIO_InitTypeDef GPIO_InitStruct = {0};
 
 /* GPIO Ports Clock Enable */
 __HAL_RCC_GPIOC_CLK_ENABLE();
 __HAL_RCC_GPIOB_CLK_ENABLE();
 
 /*Configure GPIO pin Output Level */
 HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, GPIO_PIN_RESET);
 
 /*Configure GPIO pin : PB7 */
 GPIO_InitStruct.Pin = GPIO_PIN_7;
 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 
}
 
/* USER CODE BEGIN 4 */
 
/* USER CODE END 4 */
 
/**
 * @brief This function is executed in case of error occurrence.
 * @retval None
 */
void Error_Handler(void)
{
 /* USER CODE BEGIN Error_Handler_Debug */
 /* User can add his own implementation to report the HAL error return state */
 __disable_irq();
 while (1)
 {
 }
 /* USER CODE END Error_Handler_Debug */
}
 
#ifdef USE_FULL_ASSERT
/**
 * @brief Reports the name of the source file and the source line number
 * where the assert_param error has occurred.
 * @param file: pointer to the source file name
 * @param line: assert_param error line source number
 * @retval None
 */
void assert_failed(uint8_t *file, uint32_t line)
{
 /* USER CODE BEGIN 6 */
 /* User can add his own implementation to report the file name and line number,
 ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
 /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
 
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

[Imen.D]

Hello @Shilpashree Madhu​ ,

I advise you this FAQ: How to configure the RTC to wake up the STM32 periodically from Low Power modes, this will help you to configure the RTC peripheral of the STM32 to wake up the STM32 periodically from STOP2 mode.

I hope this helps !

When your question is answered, please close this topic by choosing Select as Best.

Imen

[Shilpashree Madhu]

Thanks for your response @Imen DAHMEN​ , it was very informatiive & got the solution.

[Peter BENSCH]

Well, @Shilpashree Madhu​, you already took your code from there, right?

But let's analyze the code again and your modification:

• we assume you are using LSE with a crystal of 32.768kHz
• predivider:
  • line 188: the asynchronous predivider is set to 127+1 = 2^7
  • line 189: the synchronous predivider is set to 255+1 = 2^8
  • together they give a predivider of 2^7 * 2^8 = 2^15 = 32768, which creates an RTC input clock (ck_spre) of 2^15Hz / 2^15 = 1Hz
• RTC:
  • line 104: RTC gets its clock from RTC_WAKEUPCLOCK_CK_SPRE_17BITS, which adds 0x10000 = 65536 to the register WUT (see reference [1] at the bottom)
  • line 104: WUT is set to 0x3C08D = 245901
  • so it'll take 245901 + 65536 +1 = 311438 clock cycles of ck_spre to raise a WakeUp interrupt
  • periodic time for the interrupt will be WUT(total) / ck_spre = 311438 / 1Hz = 311438s

It means you will see an interrupt, i.e. a wakeup, after 3 days 14 hours 30 minutes, 38 secs. :D

Please change:

• RTC_WAKEUPCLOCK_CK_SPRE_17BITS to RTC_WAKEUPCLOCK_CK_SPRE_16BITS
• 0x3C08D to 119 (or 0x77, if you prefer)

then you should get a 1 second flash every 2 minutes.

[1] see RM0432, section 46.6.3 RTC control register RTC_CR, bits WUCKSEL:

WUT = Wakeup unit counter value. WUT = (0x0000 to 0xFFFF) + 0x10000 added when WUCKSEL[2:1 = 11].

--> WUCKSEL[2:1 = 11] = RTC_WAKEUPCLOCK_CK_SPRE_17BITS

Does it answer your question?

Regards

/Peter

[Shilpashree Madhu]

Thank you very much @Peter BENSCH​ 

Your explanation was very informative & conceptual & got the solution.