U585 coming up from shutdown every +-30 seconds, when I'm trying to configure for every 5 mins

[ruvianDC]

Hi.

I'm trying to configure a wake-up alarm (Alarm A) to wake up (for a test) after 5 minutes, being time 0 when I turn it on, but I can't even make it work the first alarm because it keeps waking up every 30 seconds or so.

I'm using the U585.

Sometimes the alarm A flag becomes 1, and it works, but it's rare.

Here is the code related to that:

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 */
  __HAL_DBGMCU_FREEZE_IWDG();
  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* Configure the System Power */
  SystemPower_Config();

  /* USER CODE BEGIN SysInit */

  wakeup_reason = get_wakeup_reason();
  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_GPDMA1_Init();
  MX_DCACHE1_Init();
  MX_ICACHE_Init();
  MX_USART1_UART_Init();
  MX_IWDG_Init();
  MX_TIM5_Init();
  MX_RTC_Init();
  MX_I2C2_Init();
  MX_ADC1_Init();
  MX_SPI1_Init();
  MX_TIM1_Init();
  MX_SAI1_Init();
  MX_TIM7_Init();
  MX_TIM15_Init();
  MX_TIM16_Init();
  /* USER CODE BEGIN 2 */
  __HAL_RCC_PWR_CLK_ENABLE(); // I don't know if this should be here, elsewhere or even not called

  if (__HAL_PWR_GET_FLAG(PWR_FLAG_SBF) != RESET)
  {
    __HAL_PWR_CLEAR_FLAG(PWR_FLAG_SBF);

    if (__HAL_RTC_ALARM_GET_FLAG(&hrtc, RTC_FLAG_ALRAF) != RESET)
    {
      flagWakeUpScheduling = true;

      __HAL_RTC_ALARM_CLEAR_FLAG(&hrtc, RTC_FLAG_ALRAF);
    }
  }
  custom_main();
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
  }
  /* USER CODE END WHILE */

  /* USER CODE BEGIN 3 */
/* USER CODE END 3 */
}

uint8_t get_wakeup_reason()
{
  if (__HAL_RCC_GET_FLAG(RCC_FLAG_BORRST))
  {
    __HAL_RCC_CLEAR_RESET_FLAGS();
  }
  if (__HAL_PWR_GET_FLAG(PWR_WAKEUP_FLAG1) ||
    __HAL_PWR_GET_FLAG(PWR_WAKEUP_FLAG7))
  {
    __HAL_PWR_CLEAR_FLAG(PWR_WAKEUP_FLAG1);
    __HAL_PWR_CLEAR_FLAG(PWR_WAKEUP_FLAG7);
  }
  MX_GPIO_Init();
  GPIO_InitTypeDef GPIO_InitStruct = { 0 };

  // enter_sleep(); // commented here so the other wake ups won't make it sleep again
  return 0;
}

/* RTC init function */
void MX_RTC_Init(void)
{
  /* USER CODE BEGIN RTC_Init 0 */

  /* USER CODE END RTC_Init 0 */

  RTC_PrivilegeStateTypeDef privilegeState = {0};
  RTC_TimeTypeDef sTime = {0};
  RTC_DateTypeDef sDate = {0};
  RTC_AlarmTypeDef sAlarm = {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;
  hrtc.Init.OutPutPullUp = RTC_OUTPUT_PULLUP_NONE;
  hrtc.Init.BinMode = RTC_BINARY_NONE;
  if (HAL_RTC_Init(&hrtc) != HAL_OK)
  {
    Error_Handler();
  }
  privilegeState.rtcPrivilegeFull = RTC_PRIVILEGE_FULL_NO;
  privilegeState.backupRegisterPrivZone = RTC_PRIVILEGE_BKUP_ZONE_NONE;
  privilegeState.backupRegisterStartZone2 = RTC_BKP_DR0;
  privilegeState.backupRegisterStartZone3 = RTC_BKP_DR0;
  if (HAL_RTCEx_PrivilegeModeSet(&hrtc, &privilegeState) != HAL_OK)
  {
    Error_Handler();
  }

  /* USER CODE BEGIN Check_RTC_BKUP */
  // UNUSED(sTime);
  // UNUSED(sDate);
  // UNUSED(sAlarm);

  /* USER CODE END Check_RTC_BKUP */

  /** Initialize RTC and set the Time and Date
  */

  sTime.Hours = 0;
  sTime.Minutes = 0;
  sTime.Seconds = 0;
  sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
  sTime.StoreOperation = RTC_STOREOPERATION_RESET;
  if (HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BIN) != HAL_OK)
  {
    Error_Handler();
  }
  sDate.WeekDay = RTC_WEEKDAY_MONDAY;
  sDate.Month = RTC_MONTH_JANUARY;
  sDate.Date = 1;
  sDate.Year = 0;
  if (HAL_RTC_SetDate(&hrtc, &sDate, RTC_FORMAT_BIN) != HAL_OK)
  {
    Error_Handler();
  }

  /** Enable the Alarm A
  */
  sAlarm.AlarmTime.Hours = 0;
  sAlarm.AlarmTime.Minutes = 5;
  sAlarm.AlarmTime.Seconds = 0;
  sAlarm.AlarmTime.SubSeconds = 0;
  sAlarm.AlarmMask = RTC_ALARMMASK_NONE;
  sAlarm.AlarmSubSecondMask = RTC_ALARMSUBSECONDMASK_ALL;
  sAlarm.AlarmDateWeekDaySel = RTC_ALARMDATEWEEKDAYSEL_DATE;
  sAlarm.AlarmDateWeekDay = 1;
  sAlarm.Alarm = RTC_ALARM_A;
  if (HAL_RTC_SetAlarm_IT(&hrtc, &sAlarm, RTC_FORMAT_BIN) != HAL_OK)
  {
    Error_Handler();
  }

  /** Enable the Alarm B
  *//*
 sAlarm.Alarm = RTC_ALARM_B;
 if (HAL_RTC_SetAlarm_IT(&hrtc, &sAlarm, RTC_FORMAT_BIN) != HAL_OK)
 {
   Error_Handler();
 }
 */
 // Enable the WakeUp
 // I'm not sure if this next line should be commented or not; both ways don't work
  if (HAL_RTCEx_SetWakeUpTimer_IT(&hrtc, 0, RTC_WAKEUPCLOCK_RTCCLK_DIV16, 0) != HAL_OK)
  {
    Error_Handler();
  }
 
  /* USER CODE BEGIN RTC_Init 2 */

  /* USER CODE END RTC_Init 2 */

}

void custom_main(void)
{
  // HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1); // is this needed?

  HAL_PWR_EnableBkUpAccess();
  DWT_Delay_Init();

  // WatchDog Refresh
  HAL_IWDG_Refresh(&hiwdg);

  while (1)
  {
	    if (__HAL_RTC_ALARM_GET_FLAG(&hrtc, RTC_FLAG_ALRAF) != RESET)
	    {
	      flagWakeUpScheduling = true; // it never gets to here

	      __HAL_RTC_ALARM_CLEAR_FLAG(&hrtc, RTC_FLAG_ALRAF);
	    }
	    if (flagWakeUpScheduling)
	    {
	    	flagWakeUpScheduling = false;
        }
}

 I know I have a part that is repeated twice, but knowing that *sometimes* the RTC_FLAG_ALRAF is true, I tried catching it in other moments.

Thanks in advance.