自学教程：C++ HAL_PWR_EnableBkUpAccess函数代码示例

void rtc_init_start(bool force_init) {    RTCHandle.Instance = RTC;    /* Configure RTC prescaler and RTC data registers */    /* RTC configured as follow:      - Hour Format    = Format 24      - Asynch Prediv  = Value according to source clock      - Synch Prediv   = Value according to source clock      - OutPut         = Output Disable      - OutPutPolarity = High Polarity      - OutPutType     = Open Drain */    RTCHandle.Init.HourFormat = RTC_HOURFORMAT_24;    RTCHandle.Init.AsynchPrediv = RTC_ASYNCH_PREDIV;    RTCHandle.Init.SynchPrediv = RTC_SYNCH_PREDIV;    RTCHandle.Init.OutPut = RTC_OUTPUT_DISABLE;    RTCHandle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;    RTCHandle.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;    rtc_need_init_finalise = false;    if (!force_init) {        uint32_t bdcr = RCC->BDCR;        if ((bdcr & (RCC_BDCR_RTCEN | RCC_BDCR_RTCSEL | RCC_BDCR_LSEON | RCC_BDCR_LSERDY))            == (RCC_BDCR_RTCEN | RCC_BDCR_RTCSEL_0 | RCC_BDCR_LSEON | RCC_BDCR_LSERDY)) {            // LSE is enabled & ready --> no need to (re-)init RTC            // remove Backup Domain write protection            HAL_PWR_EnableBkUpAccess();            // Clear source Reset Flag            __HAL_RCC_CLEAR_RESET_FLAGS();            // provide some status information            rtc_info |= 0x40000 | (RCC->BDCR & 7) | (RCC->CSR & 3) << 8;            return;        } else if ((bdcr & (RCC_BDCR_RTCEN | RCC_BDCR_RTCSEL))            == (RCC_BDCR_RTCEN | RCC_BDCR_RTCSEL_1)) {            // LSI configured as the RTC clock source --> no need to (re-)init RTC            // remove Backup Domain write protection            HAL_PWR_EnableBkUpAccess();            // Clear source Reset Flag            __HAL_RCC_CLEAR_RESET_FLAGS();            // Turn the LSI on (it may need this even if the RTC is running)            RCC->CSR |= RCC_CSR_LSION;            // provide some status information            rtc_info |= 0x80000 | (RCC->BDCR & 7) | (RCC->CSR & 3) << 8;            return;        }    }    rtc_startup_tick = HAL_GetTick();    rtc_info = 0x3f000000 | (rtc_startup_tick & 0xffffff);    if (rtc_use_lse) {        if (lse_magic()) {            // don't even try LSE            rtc_use_lse = false;            rtc_info &= ~0x01000000;        }    }    PYB_RTC_MspInit_Kick(&RTCHandle, rtc_use_lse);}

/**  * @brief  Initialize RTC block  *  * @note  * @param  None  * @retval None  */static void Init_RTC(void){    /* Initialize the HW - 37Khz LSI being used*/  /* Enable the LSI clock */  __HAL_RCC_LSI_ENABLE();    /* Enable power module clock */  __PWR_CLK_ENABLE();    /* Enable acces to the RTC registers */  HAL_PWR_EnableBkUpAccess();    /**   *  Write twice the value to flush the APB-AHB bridge   *  This bit shall be written in the register before writing the next one   */  HAL_PWR_EnableBkUpAccess();  /* Select LSI as RTC Input */  __HAL_RCC_RTC_CONFIG(RCC_RTCCLKSOURCE_LSI);    /* Enable RTC */  __HAL_RCC_RTC_ENABLE();    hrtc.Instance = RTC;                  /**< Define instance */  hrtc.Lock = HAL_UNLOCKED;             /**< Initialize lock */  hrtc.State = HAL_RTC_STATE_READY;     /**< Initialize state */    /**  * Bypass the shadow register  */  HAL_RTCEx_EnableBypassShadow(&hrtc);    /**  * Set the Asynchronous prescaler  */  hrtc.Init.AsynchPrediv = RTC_ASYNCH_PRESCALER;  hrtc.Init.SynchPrediv = RTC_SYNCH_PRESCALER;  HAL_RTC_Init(&hrtc);    /* Disable Write Protection */  __HAL_RTC_WRITEPROTECTION_DISABLE(&hrtc) ;    HAL_APP_RTC_Set_Wucksel(&hrtc, WUCKSEL_DIVIDER);  /**< Tick timer is 55us */    /* Wait for LSI to be stable */  while(__HAL_RCC_GET_FLAG(RCC_FLAG_LSIRDY) == 0);    return;}

/**  * @brief  This function configures the system to enter Standby mode with  *         backup SRAM ON for current consumption measurement purpose.  *         STANDBY Mode  *         ============  *           - RTC OFF  *           - IWDG and LSI OFF  *           - Backup SRAM ON  *           - Wakeup using WakeUp Pin (PI.11)  * @param  None  * @retval None  */void StandbyBKPSRAMMode_Measure(void){  /* Enable Power Clock*/  __HAL_RCC_PWR_CLK_ENABLE();  /* Allow access to Backup */  HAL_PWR_EnableBkUpAccess();  /* Reset RTC Domain */  __HAL_RCC_BACKUPRESET_FORCE();  __HAL_RCC_BACKUPRESET_RELEASE();  /* Disable all used wakeup sources: Pin6(PI.11) */  HAL_PWR_DisableWakeUpPin(PWR_WAKEUP_PIN6);  /* Clear all related wakeup flags */  __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);  /* Re-enable all used wakeup sources: Pin6(PI.11) */  HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN6);  /* Enable BKPRAM Clock */  __HAL_RCC_BKPSRAM_CLK_ENABLE();  /* Enable the Backup SRAM low power Regulator */  HAL_PWREx_EnableBkUpReg();  /* Request to enter STANDBY mode  */  HAL_PWR_EnterSTANDBYMode();}

void rtc_init(void){    RCC_OscInitTypeDef RCC_OscInitStruct;    uint32_t rtc_freq = 0;    if (rtc_inited) return;    rtc_inited = 1;    RtcHandle.Instance = RTC;	    // Check if RTC is already initialized    if ((RTC->ISR & RTC_ISR_INITS) ==  RTC_ISR_INITS) return;    // Enable Power clock    __PWR_CLK_ENABLE();    // Enable access to Backup domain    HAL_PWR_EnableBkUpAccess();    // Reset Backup domain    __HAL_RCC_BACKUPRESET_FORCE();    __HAL_RCC_BACKUPRESET_RELEASE();    // Enable LSE Oscillator    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;    RCC_OscInitStruct.PLL.PLLState   = RCC_PLL_NONE; /* Mandatory, otherwise the PLL is reconfigured! */    RCC_OscInitStruct.LSEState       = RCC_LSE_ON; /* External 32.768 kHz clock on OSC_IN/OSC_OUT */    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) == HAL_OK) {        // Connect LSE to RTC        __HAL_RCC_RTC_CONFIG(RCC_RTCCLKSOURCE_LSE);        rtc_freq = LSE_VALUE;    } else {        // Enable LSI clock        RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_LSE;        RCC_OscInitStruct.PLL.PLLState   = RCC_PLL_NONE; // Mandatory, otherwise the PLL is reconfigured!        RCC_OscInitStruct.LSEState       = RCC_LSE_OFF;        RCC_OscInitStruct.LSIState       = RCC_LSI_ON;        if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {            error("RTC error: LSI clock initialization failed.");        }        // Connect LSI to RTC        __HAL_RCC_RTC_CONFIG(RCC_RTCCLKSOURCE_LSI);        // Note: The LSI clock can be measured precisely using a timer input capture.        rtc_freq = LSI_VALUE;    }    // Enable RTC    __HAL_RCC_RTC_ENABLE();    RtcHandle.Init.HourFormat     = RTC_HOURFORMAT_24;    RtcHandle.Init.AsynchPrediv   = 127;    RtcHandle.Init.SynchPrediv    = (rtc_freq / 128) - 1;    RtcHandle.Init.OutPut         = RTC_OUTPUT_DISABLE;    RtcHandle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;    RtcHandle.Init.OutPutType     = RTC_OUTPUT_TYPE_OPENDRAIN;    if (HAL_RTC_Init(&RtcHandle) != HAL_OK) {        error("RTC error: RTC initialization failed.");    }}

/** @defgroup HAL_MSP_Private_Functions  * @{  */void HAL_IWDG_MspInit(IWDG_HandleTypeDef* hiwdg){  __HAL_RCC_PWR_CLK_ENABLE();   HAL_PWR_EnableBkUpAccess();   }

void rtc_free(void){    // Enable Power clock    __PWR_CLK_ENABLE();    // Enable access to Backup domain    HAL_PWR_EnableBkUpAccess();    // Reset Backup domain    __HAL_RCC_BACKUPRESET_FORCE();    __HAL_RCC_BACKUPRESET_RELEASE();    // Disable access to Backup domain    HAL_PWR_DisableBkUpAccess();    // Disable LSI and LSE clocks    RCC_OscInitTypeDef RCC_OscInitStruct;    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_LSE;    RCC_OscInitStruct.PLL.PLLState   = RCC_PLL_NONE;    RCC_OscInitStruct.LSIState       = RCC_LSI_OFF;    RCC_OscInitStruct.LSEState       = RCC_LSE_OFF;    HAL_RCC_OscConfig(&RCC_OscInitStruct);    rtc_inited = 0;}

void HAL_RTC_MspInit(RTC_HandleTypeDef *hrtc){    RCC_OscInitTypeDef        RCC_OscInitStruct;    RCC_PeriphCLKInitTypeDef  PeriphClkInitStruct;    __HAL_RCC_PWR_CLK_ENABLE();    HAL_PWR_EnableBkUpAccess();    /*##-2- Configure LSE as RTC clock source ###################################*/    RCC_OscInitStruct.OscillatorType =  RCC_OSCILLATORTYPE_LSE;    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;    RCC_OscInitStruct.LSEState = RCC_LSE_ON;    if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)    {        //Error_Handler();    }    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;    PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;    if(HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)    {        //Error_Handler();    }    /*##-3- Enable RTC peripheral Clocks #######################################*/    /* Enable RTC Clock */    __HAL_RCC_RTC_ENABLE();}

/* USER CODE BEGIN 1 */static void rtc_backup_init(){	uint32_t temp;	//__HAL_RCC_BKP_CLK_ENABLE();//for backup sram  /* Allow access to Backup */  HAL_PWR_EnableBkUpAccess();}

/**  * @brief RTC MSP Initialization  *        This function configures the hardware resources used in this example:  *           - Peripheral's clock enable  * @param hrtc: RTC handle pointer  * @note  Care must be taken when HAL_RCCEx_PeriphCLKConfig() is used to select   *        the RTC clock source; in this case the Backup domain will be reset in    *        order to modify the RTC Clock source, as consequence RTC registers (including   *        the backup registers) and RCC_CSR register are set to their reset values.    * @retval None  */void HAL_RTC_MspInit(RTC_HandleTypeDef *hrtc){  RCC_OscInitTypeDef RCC_OscInitStruct;  RCC_PeriphCLKInitTypeDef  PeriphClkInitStruct;  /*##-1- Enables the PWR Clock and Enables access to the backup domain ###################################*/  /* To change the source clock of the RTC feature (LSE, LSI), You have to:     - Enable the power clock using __HAL_RCC_PWR_CLK_ENABLE()     - Enable write access using HAL_PWR_EnableBkUpAccess() function before to        configure the RTC clock source (to be done once after reset).     - Reset the Back up Domain using __HAL_RCC_BACKUPRESET_FORCE() and        __HAL_RCC_BACKUPRESET_RELEASE().     - Configure the needed RTC clock source */  __HAL_RCC_PWR_CLK_ENABLE();  HAL_PWR_EnableBkUpAccess();    /* Enable BKP CLK enable for backup registers */  __HAL_RCC_BKP_CLK_ENABLE();  #ifdef RTC_CLOCK_SOURCE_LSE    RCC_OscInitStruct.OscillatorType =  RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_LSE;  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;  RCC_OscInitStruct.LSEState = RCC_LSE_ON;  RCC_OscInitStruct.LSIState = RCC_LSI_OFF;  if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)  {     Error_Handler();  }    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;  PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;  if(HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)  {     Error_Handler();  }#elif defined (RTC_CLOCK_SOURCE_LSI)    RCC_OscInitStruct.OscillatorType =  RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_LSE;  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;  RCC_OscInitStruct.LSIState = RCC_LSI_ON;  RCC_OscInitStruct.LSEState = RCC_LSE_OFF;  if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)  {     Error_Handler();  }  PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;  PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;  if(HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)  {     Error_Handler();  }#else#error Please select the RTC Clock source inside the main.h file#endif /*RTC_CLOCK_SOURCE_LSE*/  /*##-2- Enable the RTC & BKP peripheral Clock ##############################*/  /* Enable RTC Clock */  __HAL_RCC_RTC_ENABLE();  }

/**  * @brief LCD MSP Init.  * @param hlcd: LCD handle  * @retval None  */ void HAL_LCD_MspInit(LCD_HandleTypeDef *hlcd){  GPIO_InitTypeDef  GPIO_InitStruct;  RCC_OscInitTypeDef RCC_OscInitStruct;    /*##-1- Enable PWR  peripheral Clock #######################################*/  __PWR_CLK_ENABLE();    /*##-2- Allow Access and Reset the Backup Domaine ##########################*/   /* Allow Access to Backup Domaine */  HAL_PWR_EnableBkUpAccess();    /* Reset the Backup Domaine */  __HAL_RCC_BACKUPRESET_FORCE();   __HAL_RCC_BACKUPRESET_RELEASE();    /*##-3- Configue LSE as RTC clock soucre ###################################*/   RCC_OscInitStruct.OscillatorType =  RCC_OSCILLATORTYPE_LSE;  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;  RCC_OscInitStruct.LSEState = RCC_LSE_ON;  if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)  {     /* Infinite loop */    while(1);  }  __HAL_RCC_RTC_CONFIG(RCC_RTCCLKSOURCE_LSE);      /*##-4- Enable LCD GPIO Clocks #############################################*/  __GPIOA_CLK_ENABLE();  __GPIOB_CLK_ENABLE();  __GPIOC_CLK_ENABLE();    /*##-5- Configure peripheral GPIO ##########################################*/  /* Configure Output for LCD */  /* Port A */    GPIO_InitStruct.Pin       =  GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_8 | GPIO_PIN_9 |GPIO_PIN_10 |GPIO_PIN_15;  GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;  GPIO_InitStruct.Pull      = GPIO_NOPULL;  GPIO_InitStruct.Speed     = GPIO_SPEED_FAST;  GPIO_InitStruct.Alternate = GPIO_AF1_LCD;  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);      /* Configure Output for LCD */  /* Port B */    GPIO_InitStruct.Pin       = GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_8 | GPIO_PIN_9 /    | GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15;   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);      /* Configure Output for LCD */  /* Port C*/    GPIO_InitStruct.Pin       = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_6 /    | GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 |GPIO_PIN_11 ;   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);    /*##-6- Enable LCD peripheral Clock ########################################*/  __LCD_CLK_ENABLE();}

/**  * @brief  This function configures the system to enter Standby mode for  *         current consumption measurement purpose.  *         STANDBY Mode  *         ============  *           - Backup SRAM and RTC OFF  *           - IWDG and LSI OFF  *           - Wakeup using WakeUp Pin (PA.00)  * @param  None  * @retval None  */void StandbyMode_Measure(void){  /* Enable Power Clock*/  __HAL_RCC_PWR_CLK_ENABLE();    /* Allow access to Backup */  HAL_PWR_EnableBkUpAccess();  /* Reset RTC Domain */  __HAL_RCC_BACKUPRESET_FORCE();  __HAL_RCC_BACKUPRESET_RELEASE();    /* Disable all used wakeup sources: Pin1(PA.0) */  HAL_PWR_DisableWakeUpPin(PWR_WAKEUP_PIN1);    /* Clear all related wakeup flags */  __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);    /* Re-enable all used wakeup sources: Pin1(PA.0) */  HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);  /*## Enter Standby Mode ####################################################*/  /* Request to enter STANDBY mode  */  HAL_PWR_EnterSTANDBYMode(); }

/**  * @brief  This function configures the system to enter Standby mode for  *         current consumption measurement purpose.  *         STANDBY Mode  *         ============  *           - RTC OFF  *           - IWDG and LSI OFF  *           - Wakeup using WakeUp Pin (wire Vdd to PA.00)  * @retval None  */void StandbyMode_Measure(void){  /* Enable Power Clock*/  __HAL_RCC_PWR_CLK_ENABLE();  /* Allow access to Backup */  HAL_PWR_EnableBkUpAccess();  /* Reset RTC Domain */  __HAL_RCC_BACKUPRESET_FORCE();  __HAL_RCC_BACKUPRESET_RELEASE();    /* The Following Wakeup sequence is highly recommended prior to each Standby mode entry     mainly  when using more than one wakeup source this is to not miss any wakeup event.       - Disable all used wakeup sources,       - Clear all related wakeup flags,        - Re-enable all used wakeup sources,       - Enter the Standby mode.  */    /*#### Disable all used wakeup sources: WKUP pin ###########################*/  HAL_PWR_DisableWakeUpPin(PWR_WAKEUP_PIN1);    /*#### Clear all related wakeup flags ######################################*/  /* Clear PWR wake up Flag */  __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);    /* Enable WKUP pin */  HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);    /* Request to enter STANDBY mode */  HAL_PWR_EnterSTANDBYMode();}

/**  * @brief  Configures the RTC.  * @param  None  * @retval None  */static void RTC_Config(void){  /* Enable Power Clock*/  __PWR_CLK_ENABLE();    /* Allow Access to RTC Backup domaine */  HAL_PWR_EnableBkUpAccess();    RtcHandle.Instance= RTC;    /* Check if the system was resumed from StandBy mode */  if (__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET)  {    /* Clear StandBy flag */    __HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);    /* Disable the write protection for RTC registers */    __HAL_RTC_WRITEPROTECTION_DISABLE(&RtcHandle);    /* Wait for RTC APB registers synchronisation (needed after start-up from Reset)*/    if (HAL_RTC_WaitForSynchro(&RtcHandle) != HAL_OK)    {      while(1);    }    /* Enable the write protection for RTC registers */    __HAL_RTC_WRITEPROTECTION_ENABLE(&RtcHandle);    /* No need to configure the RTC as the RTC config(clock source, enable,    prescaler,...) are kept after wake-up from STANDBY */  }  else  {    /* Reset Backup Domaine */    __HAL_RCC_BACKUPRESET_FORCE();    __HAL_RCC_BACKUPRESET_RELEASE();    /* Set the RTC time base to 1s */        /* Configure RTC prescaler and RTC data registers as follows:    - Hour Format = Format 24    - Asynch Prediv = Value according to source clock    - Synch Prediv = Value according to source clock    - OutPut = Output Disable    - OutPutPolarity = High Polarity    - OutPutType = Open Drain */    RtcHandle.Init.HourFormat = RTC_HOURFORMAT_24;    RtcHandle.Init.AsynchPrediv = RTC_ASYNCH_PREDIV;    RtcHandle.Init.SynchPrediv = RTC_SYNCH_PREDIV;    RtcHandle.Init.OutPut = RTC_OUTPUT_DISABLE;    RtcHandle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;    RtcHandle.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;    if(HAL_RTC_Init(&RtcHandle) != HAL_OK)    {      /* Initialization Error */      while(1);    }  }}

/**  * @brief IWDG MSP Initialization   *        This function configures the hardware resources used in this example:   *           - Peripheral's clock enable   *           - LSI enable   * @param hwwdg: IWDG handle pointer  * @retval None  */void HAL_IWDG_MspInit(IWDG_HandleTypeDef* hiwdg){  __PWR_CLK_ENABLE();   HAL_PWR_EnableBkUpAccess();    /*## Enable peripherals and GPIO Clocks ####################################*/  /* RCC LSI clock enable */  __HAL_RCC_LSI_ENABLE();    /* Wait till LSI is ready */  while (__HAL_RCC_GET_FLAG(RCC_FLAG_LSIRDY) == RESET)  {} }

void ParamInit(void){    uint8_t i;    sParamGeneral paramGeneral;    Flash_M25P64_Read_Buffer((uint8_t*)&paramGeneral, ADDRESS_PARAM_GENERAL, sizeof(paramGeneral));    if(paramGeneral.final != FINAL_OK)	{	/* if settings are empty, usb mode */        HAL_PWR_EnableBkUpAccess();        BACUP_STATUS->BACUP_STATUS_REG = USB_ENABLED;        HAL_PWR_DisableBkUpAccess();        NVIC_SystemReset();    }    else    {

void rtc_init(void){    RCC_OscInitTypeDef RCC_OscInitStruct;    if (rtc_inited) return;    rtc_inited = 1;    RtcHandle.Instance = RTC;    // Enable Power clock    __HAL_RCC_PWR_CLK_ENABLE();    // Enable access to Backup domain    HAL_PWR_EnableBkUpAccess();    // Reset Backup domain    __HAL_RCC_BACKUPRESET_FORCE();    __HAL_RCC_BACKUPRESET_RELEASE();    // Enable LSE Oscillator    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;    RCC_OscInitStruct.PLL.PLLState   = RCC_PLL_NONE; // Mandatory, otherwise the PLL is reconfigured!    RCC_OscInitStruct.LSEState       = RCC_LSE_ON; // External 32.768 kHz clock on OSC_IN/OSC_OUT    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) == HAL_OK) {        // Connect LSE to RTC        __HAL_RCC_RTC_CONFIG(RCC_RTCCLKSOURCE_LSE);    } else {        // Enable LSI clock        RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_LSE;        RCC_OscInitStruct.PLL.PLLState   = RCC_PLL_NONE; // Mandatory, otherwise the PLL is reconfigured!        RCC_OscInitStruct.LSEState       = RCC_LSE_OFF;        RCC_OscInitStruct.LSIState       = RCC_LSI_ON;        if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {            error("RTC error: LSI clock initialization failed.");        }        // Connect LSI to RTC        __HAL_RCC_RTC_CONFIG(RCC_RTCCLKSOURCE_LSI);    }    // Enable RTC    __HAL_RCC_RTC_ENABLE();    RtcHandle.Init.AsynchPrediv = RTC_AUTO_1_SECOND;    if (HAL_RTC_Init(&RtcHandle) != HAL_OK) {        error("RTC error: RTC initialization failed.");    }}

void rtc_init(void) {    if (rtc_inited) return;    rtc_inited = 1;    RtcHandle.Instance = RTC;    // Enable Power clock    __PWR_CLK_ENABLE();    // Allow access to RTC    HAL_PWR_EnableBkUpAccess();    // Reset Backup domain    __HAL_RCC_BACKUPRESET_FORCE();     __HAL_RCC_BACKUPRESET_RELEASE();      // Enable LSI clock    RCC_OscInitTypeDef RCC_OscInitStruct;    RCC_OscInitStruct.OscillatorType =  RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_LSE;    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;    RCC_OscInitStruct.LSIState = RCC_LSI_ON;    RCC_OscInitStruct.LSEState = RCC_LSE_OFF;    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {        error("RTC error: LSI clock initialization failed.");     }        // Connect LSI to RTC    __HAL_RCC_RTC_CLKPRESCALER(RCC_RTCCLKSOURCE_LSI);    __HAL_RCC_RTC_CONFIG(RCC_RTCCLKSOURCE_LSI);        // Enable RTC clock    __HAL_RCC_RTC_ENABLE();        // [TODO] This value is LSI typical value. To be measured precisely using a timer input capture    uint32_t lsi_freq = 32000;        RtcHandle.Init.HourFormat     = RTC_HOURFORMAT_24;    RtcHandle.Init.AsynchPrediv   = 127;    RtcHandle.Init.SynchPrediv    = (lsi_freq / 128) - 1;    RtcHandle.Init.OutPut         = RTC_OUTPUT_DISABLE;    RtcHandle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;    RtcHandle.Init.OutPutType     = RTC_OUTPUT_TYPE_OPENDRAIN;    if (HAL_RTC_Init(&RtcHandle) != HAL_OK) {        error("RTC error: RTC initialization failed.");     }}

void HAL_RTC_MspInit(RTC_HandleTypeDef* hrtc){  if(hrtc->Instance==RTC)  {  /* USER CODE BEGIN RTC_MspInit 0 */  /* USER CODE END RTC_MspInit 0 */    HAL_PWR_EnableBkUpAccess();    /* Enable BKP CLK enable for backup registers */    __HAL_RCC_BKP_CLK_ENABLE();    /* Peripheral clock enable */    __HAL_RCC_RTC_ENABLE();  /* USER CODE BEGIN RTC_MspInit 1 */  /* USER CODE END RTC_MspInit 1 */  }}

/**  * @brief RTC MSP Initialization   *        This function configures the hardware resources used in this example  * @param hrtc RTC handle pointer  *   * @note  Care must be taken when HAL_RCCEx_PeriphCLKConfig() is used to select   *        the RTC clock source; in this case the Backup domain will be reset in    *        order to modify the RTC Clock source, as consequence RTC registers (including   *        the backup registers) and RCC_BDCR register are set to their reset values.  *               * @retval None  */void HAL_RTC_MspInit(RTC_HandleTypeDef *hrtc){  RCC_OscInitTypeDef        RCC_OscInitStruct;  RCC_PeriphCLKInitTypeDef  PeriphClkInitStruct;  /*##-1- Enables the PWR Clock and Enables access to the backup domain ###################################*/  /* To change the source clock of the RTC feature (LSE, LSI), You have to:     - Enable the power clock using __HAL_RCC_PWR_CLK_ENABLE()     - Enable write access using HAL_PWR_EnableBkUpAccess() function before to        configure the RTC clock source (to be done once after reset).     - Reset the Back up Domain using __HAL_RCC_BACKUPRESET_FORCE() and        __HAL_RCC_BACKUPRESET_RELEASE().     - Configure the needed RTc clock source */  __HAL_RCC_PWR_CLK_ENABLE();  HAL_PWR_EnableBkUpAccess();#ifdef RTC_CLOCK_SOURCE_LSE  /* Note: For STM32F3xx MCU families it is recommended to use the low drive mode configuration    of the LSE JUMPER_POSITION (low drive capability in LSEDRV register) due to the 6pF load capacitance    of the crystal on board*/  __HAL_RCC_LSEDRIVE_CONFIG(RCC_LSEDRIVE_LOW);#endif /* RTC_CLOCK_SOURCE_LSE */    /*##-2- Configure LSE as RTC clock source ###################################*/  RCC_OscInitStruct.OscillatorType =  RCC_OSCILLATORTYPE_LSE;  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;  RCC_OscInitStruct.LSEState = RCC_LSE_ON;  if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)  {     Error_Handler();  }    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;  PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;  if(HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)  {     Error_Handler();  }    /*##-3- Enable RTC peripheral Clocks #######################################*/  /* Enable RTC Clock */  __HAL_RCC_RTC_ENABLE();}

/*    Conditions:      0    Exit points:      0    M = 0 - 0 + 2 = 2    Cyclomatic complexity      2  */void InitRTC(void){  __PWR_CLK_ENABLE();  HAL_PWR_EnableBkUpAccess();  __HAL_RCC_RTC_CONFIG(RCC_RTCCLKSOURCE_HSE_DIV16);  __HAL_RCC_RTC_ENABLE();  rtc.Instance = RTC;  rtc.Init.AsynchPrediv = 0x63; // Step down the clock by a factor of 100  rtc.Init.SynchPrediv = 0x1387; // Step down the clock by a factor of 5000  rtc.Init.HourFormat = RTC_HOURFORMAT_24;  rtc.Init.OutPut = RTC_OUTPUT_DISABLE;  rtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_LOW;  rtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;}

void HAL_RTC_MspInit(RTC_HandleTypeDef* hrtc){  if(hrtc->Instance==RTC)  {  /* USER CODE BEGIN RTC_MspInit 0 */  /* USER CODE END RTC_MspInit 0 */    HAL_PWR_EnableBkUpAccess();    /* Enable BKP CLK enable for backup registers */    __HAL_RCC_BKP_CLK_ENABLE();    /* Peripheral clock enable */    __HAL_RCC_RTC_ENABLE();    /* Peripheral interrupt init */    HAL_NVIC_SetPriority(RTC_Alarm_IRQn, 0, 0);    HAL_NVIC_EnableIRQ(RTC_Alarm_IRQn);  /* USER CODE BEGIN RTC_MspInit 1 */  /* USER CODE END RTC_MspInit 1 */  }}

void HAL_RTC_MspInit(RTC_HandleTypeDef *hrtc){  RCC_OscInitTypeDef        RCC_OscInitStruct;  RCC_PeriphCLKInitTypeDef  PeriphClkInitStruct;  (void ) hrtc;  /*##-1- Enables the PWR Clock and Enables access to the backup domain ###################################*/  /* To change the source clock of the RTC feature (LSE, LSI), You have to:     - Enable the power clock using __PWR_CLK_ENABLE()     - Enable write access using HAL_PWR_EnableBkUpAccess() function before to       configure the RTC clock source (to be done once after reset).     - Reset the Back up Domain using __HAL_RCC_BACKUPRESET_FORCE() and       __HAL_RCC_BACKUPRESET_RELEASE().     - Configure the needed RTc clock source */  __PWR_CLK_ENABLE();  HAL_PWR_EnableBkUpAccess();  /*##-2- Configue LSE as RTC clock soucre ###################################*/  RCC_OscInitStruct.OscillatorType =  RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_LSE;  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;  RCC_OscInitStruct.LSEState = RCC_LSE_ON;  RCC_OscInitStruct.LSIState = RCC_LSI_OFF;  if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)  {    Error_Handler();  }  PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;  PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;  if(HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)  {    Error_Handler();  }  /*##-3- Enable RTC peripheral Clocks #######################################*/  /* Enable RTC Clock */  __HAL_RCC_RTC_ENABLE();}

void checkForBootLoaderRequest(void){    uint32_t bt;    __PWR_CLK_ENABLE();    __BKPSRAM_CLK_ENABLE();    HAL_PWR_EnableBkUpAccess();    bt = (*(__IO uint32_t *) (BKPSRAM_BASE + 4)) ;    if ( bt == 0xDEADBEEF ) {        (*(__IO uint32_t *) (BKPSRAM_BASE + 4)) =  0xCAFEFEED; // Reset our trigger        // Backup SRAM is write-back by default, ensure value actually reaches memory        // Another solution would be marking BKPSRAM as write-through in Memory Protection Unit settings        SCB_CleanDCache_by_Addr((uint32_t *) (BKPSRAM_BASE + 4), sizeof(uint32_t));        void (*SysMemBootJump)(void);        __SYSCFG_CLK_ENABLE();        SYSCFG->MEMRMP |= SYSCFG_MEM_BOOT_ADD0 ;        uint32_t p =  (*((uint32_t *) 0x1ff00000));        __set_MSP(p); //Set the main stack pointer to its defualt values        SysMemBootJump = (void (*)(void)) (*((uint32_t *) 0x1ff00004)); // Point the PC to the System Memory reset vector (+4)        SysMemBootJump();        while (1);    }}

void rtc_init_finalise() {    if (!rtc_need_init_finalise) {        return;    }    rtc_info = 0x20000000 | (rtc_use_lse << 28);    if (PYB_RTC_Init(&RTCHandle) != HAL_OK) {        if (rtc_use_lse) {            // fall back to LSI...            rtc_use_lse = false;            rtc_startup_tick = HAL_GetTick();            PYB_RTC_MspInit_Kick(&RTCHandle, rtc_use_lse);            HAL_PWR_EnableBkUpAccess();            RTCHandle.State = HAL_RTC_STATE_RESET;            if (PYB_RTC_Init(&RTCHandle) != HAL_OK) {                rtc_info = 0x0100ffff; // indicate error                return;            }        } else {            // init error            rtc_info = 0xffff; // indicate error            return;        }    }    // record how long it took for the RTC to start up    rtc_info |= (HAL_GetTick() - rtc_startup_tick) & 0xffff;    // fresh reset; configure RTC Calendar    RTC_CalendarConfig();    #if defined(MCU_SERIES_L4)    if(__HAL_RCC_GET_FLAG(RCC_FLAG_BORRST) != RESET) {    #else    if(__HAL_RCC_GET_FLAG(RCC_FLAG_PORRST) != RESET) {    #endif        // power on reset occurred        rtc_info |= 0x10000;    }    if(__HAL_RCC_GET_FLAG(RCC_FLAG_PINRST) != RESET) {        // external reset occurred        rtc_info |= 0x20000;    }    // Clear source Reset Flag    __HAL_RCC_CLEAR_RESET_FLAGS();    rtc_need_init_finalise = false;}STATIC HAL_StatusTypeDef PYB_RCC_OscConfig(RCC_OscInitTypeDef  *RCC_OscInitStruct) {    /*------------------------------ LSI Configuration -------------------------*/    if ((RCC_OscInitStruct->OscillatorType & RCC_OSCILLATORTYPE_LSI) == RCC_OSCILLATORTYPE_LSI) {        // Check the LSI State        if (RCC_OscInitStruct->LSIState != RCC_LSI_OFF) {            // Enable the Internal Low Speed oscillator (LSI).            __HAL_RCC_LSI_ENABLE();        } else {            // Disable the Internal Low Speed oscillator (LSI).            __HAL_RCC_LSI_DISABLE();        }    }    /*------------------------------ LSE Configuration -------------------------*/    if ((RCC_OscInitStruct->OscillatorType & RCC_OSCILLATORTYPE_LSE) == RCC_OSCILLATORTYPE_LSE) {        // Enable Power Clock        __PWR_CLK_ENABLE();        HAL_PWR_EnableBkUpAccess();        uint32_t tickstart = HAL_GetTick();        #if defined(MCU_SERIES_F7) || defined(MCU_SERIES_L4)        //__HAL_RCC_PWR_CLK_ENABLE();        // Enable write access to Backup domain        //PWR->CR1 |= PWR_CR1_DBP;        // Wait for Backup domain Write protection disable        while ((PWR->CR1 & PWR_CR1_DBP) == RESET) {            if (HAL_GetTick() - tickstart > RCC_DBP_TIMEOUT_VALUE) {                return HAL_TIMEOUT;            }        }        #else        // Enable write access to Backup domain        //PWR->CR |= PWR_CR_DBP;        // Wait for Backup domain Write protection disable        while ((PWR->CR & PWR_CR_DBP) == RESET) {            if (HAL_GetTick() - tickstart > DBP_TIMEOUT_VALUE) {                return HAL_TIMEOUT;            }        }        #endif        // Set the new LSE configuration        __HAL_RCC_LSE_CONFIG(RCC_OscInitStruct->LSEState);    }    return HAL_OK;}STATIC HAL_StatusTypeDef PYB_RTC_Init(RTC_HandleTypeDef *hrtc) {    // Check the RTC peripheral state    if (hrtc == NULL) {        return HAL_ERROR;    }//.........这里部分代码省略.........

/**  * @brief  Main program  * @param  None  * @retval None  */int main(void){  /* Enable the CPU Cache */  CPU_CACHE_Enable();    /* STM32F7xx HAL library initialization:       - Configure the Flash ART accelerator on ITCM interface       - Systick timer is configured by default as source of time base, but user          can eventually implement his proper time base source (a general purpose          timer for example or other time source), keeping in mind that Time base          duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and          handled in milliseconds basis.       - Set NVIC Group Priority to 4       - Low Level Initialization     */  HAL_Init();  /* Configure the system clock to 216 MHz */  SystemClock_Config();  /* Since MFX is used, LED init is done after clock config */  /* Configure LED1, LED2, LED3 and LED4 */  BSP_LED_Init(LED1);  BSP_LED_Init(LED2);  BSP_LED_Init(LED3);  BSP_LED_Init(LED4);  /* Tamper push-button (EXTI15_10) will be used to wakeup the system from STOP mode */  BSP_PB_Init(BUTTON_TAMPER, BUTTON_MODE_EXTI);  /*## Configure the RTC peripheral #######################################*/  /* Enable Power Clock */  __HAL_RCC_PWR_CLK_ENABLE();  /* Allow Access to RTC Backup domaine */  HAL_PWR_EnableBkUpAccess();  RTCHandle.Instance = RTC;  /* Configure RTC prescaler and RTC data registers as follows:  - Hour Format = Format 24  - Asynch Prediv = Value according to source clock  - Synch Prediv = Value according to source clock  - OutPut = Output Disable  - OutPutPolarity = High Polarity  - OutPutType = Open Drain */  RTCHandle.Init.HourFormat = RTC_HOURFORMAT_24;  RTCHandle.Init.AsynchPrediv = RTC_ASYNCH_PREDIV;  RTCHandle.Init.SynchPrediv = RTC_SYNCH_PREDIV;  RTCHandle.Init.OutPut = RTC_OUTPUT_DISABLE;  RTCHandle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;  RTCHandle.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;  if (HAL_RTC_Init(&RTCHandle) != HAL_OK)  {    /* Initialization Error */    Error_Handler();  }  while (1)  {    /* Turn On LED4 */    BSP_LED_On(LED4);    /* Insert 5 second delay */    HAL_Delay(5000);    /*## Configure the Wake up timer ###########################################*/    /*  RTC Wakeup Interrupt Generation:        Wakeup Time Base = (RTC_WAKEUPCLOCK_RTCCLK_DIV /(LSI))        Wakeup Time = Wakeup Time Base * WakeUpCounter                     = (RTC_WAKEUPCLOCK_RTCCLK_DIV /(LSI)) * WakeUpCounter        ==> WakeUpCounter = Wakeup Time / Wakeup Time Base          To configure the wake up timer to 4s the WakeUpCounter is set to 0x242B:          RTC_WAKEUPCLOCK_RTCCLK_DIV = RTCCLK_Div16 = 16           Wakeup Time Base = 16 /(~37KHz) = ~0,432 ms          Wakeup Time = ~4s = 0,432ms  * WakeUpCounter          ==> WakeUpCounter = ~4s/0,432ms = 9259 = 0x242B */    HAL_RTCEx_SetWakeUpTimer_IT(&RTCHandle, 0x242B, RTC_WAKEUPCLOCK_RTCCLK_DIV16);    /* Turn OFF LED's */    BSP_LED_Off(LED1);    BSP_LED_Off(LED2);    BSP_LED_Off(LED4);#ifdef UNDERDRIVE_MODE    __HAL_PWR_UNDERDRIVE_ENABLE();#endif /* UNDERDRIVE_MODE */    /* Enter Stop Mode */    HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);    /* Disable Wakeup Counter */    HAL_RTCEx_DeactivateWakeUpTimer(&RTCHandle);    /* Configures system clock after wake-up from STOP: enable HSE, PLL and select//.........这里部分代码省略.........

uint32_t TM_RTC_Init(TM_RTC_ClockSource_t source) {	uint32_t status;	TM_RTC_t datatime;		/* Set instance */	hRTC.Instance = RTC;	hRTC.Init.AsynchPrediv = RTC_ASYNC_PREDIV;	hRTC.Init.SynchPrediv = RTC_SYNC_PREDIV;	hRTC.Init.HourFormat = RTC_HOURFORMAT_24;	hRTC.Init.OutPut = RTC_OUTPUT_DISABLE;	hRTC.Init.OutPutType = RTC_OUTPUT_TYPE_PUSHPULL;	hRTC.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;		/* Enable PWR peripheral clock */	__HAL_RCC_PWR_CLK_ENABLE();	/* Allow access to BKP Domain */	HAL_PWR_EnableBkUpAccess();		/* Get RTC status */	status = HAL_RTCEx_BKUPRead(&hRTC, RTC_STATUS_REG);		/* Check if RTC already initialized */	if (status == RTC_STATUS_TIME_OK) {		/* Start internal clock if we choose internal clock */		if (source == TM_RTC_ClockSource_Internal) {			TM_RTC_Config(TM_RTC_ClockSource_Internal);		}				/* Wait for RTC APB registers synchronisation (needed after start-up from Reset) */		HAL_RTC_WaitForSynchro(&hRTC);				/* Get date and time */		TM_RTC_GetDateTime(&datatime, TM_RTC_Format_BIN);				/* Clear reset flags */		__HAL_RCC_CLEAR_RESET_FLAGS();				/* Return OK */		return 1;	} else {		/* Start RTC clock */		TM_RTC_Config(source);				/* Set date */		RTC_DateStruct.Year = 0;		RTC_DateStruct.Month = 1;		RTC_DateStruct.Date = 1;		RTC_DateStruct.WeekDay = RTC_WEEKDAY_TUESDAY;		/* Set date */		HAL_RTC_SetDate(&hRTC, &RTC_DateStruct, RTC_FORMAT_BIN);		/* Set time */		RTC_TimeStruct.Hours = 0x00;		RTC_TimeStruct.Minutes = 0x00;		RTC_TimeStruct.Seconds = 0x00;		RTC_TimeStruct.TimeFormat = RTC_HOURFORMAT_24;		RTC_TimeStruct.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;		RTC_TimeStruct.StoreOperation = RTC_STOREOPERATION_RESET;		/* Set time */		HAL_RTC_SetTime(&hRTC, &RTC_TimeStruct, RTC_FORMAT_BCD);				/* Init RTC */		HAL_RTC_Init(&hRTC);		/* Save data to backup regiser */		HAL_RTCEx_BKUPWrite(&hRTC, RTC_STATUS_REG, RTC_STATUS_TIME_OK); 				/* RTC was initialized now */		return 0;	}}

/**  * @brief System Clock Configuration  * @retval None  */void SystemClock_Config(void){  RCC_OscInitTypeDef RCC_OscInitStruct = {0};  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};  RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};  /**Configure LSE Drive Capability   */  HAL_PWR_EnableBkUpAccess();  /**Configure the main internal regulator output voltage   */  __HAL_RCC_PWR_CLK_ENABLE();  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);  /**Initializes the CPU, AHB and APB busses clocks   */  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI|RCC_OSCILLATORTYPE_HSE;  RCC_OscInitStruct.HSEState = RCC_HSE_ON;  RCC_OscInitStruct.LSIState = RCC_LSI_ON;  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;  RCC_OscInitStruct.PLL.PLLM = 25;  RCC_OscInitStruct.PLL.PLLN = 432;  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;  RCC_OscInitStruct.PLL.PLLQ = 9;  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)  {    Error_Handler();  }  /**Activate the Over-Drive mode   */  if (HAL_PWREx_EnableOverDrive() != HAL_OK)  {    Error_Handler();  }  /**Initializes the CPU, AHB and APB busses clocks   */  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_7) != HAL_OK)  {    Error_Handler();  }  PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LTDC|RCC_PERIPHCLK_USART1                              |RCC_PERIPHCLK_SDMMC1|RCC_PERIPHCLK_CLK48;  PeriphClkInitStruct.PLLSAI.PLLSAIN = 192;  PeriphClkInitStruct.PLLSAI.PLLSAIR = 5;  PeriphClkInitStruct.PLLSAI.PLLSAIQ = 2;  PeriphClkInitStruct.PLLSAI.PLLSAIP = RCC_PLLSAIP_DIV2;  PeriphClkInitStruct.PLLSAIDivQ = 1;  PeriphClkInitStruct.PLLSAIDivR = RCC_PLLSAIDIVR_4;  PeriphClkInitStruct.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK2;  PeriphClkInitStruct.Clk48ClockSelection = RCC_CLK48SOURCE_PLL;  PeriphClkInitStruct.Sdmmc1ClockSelection = RCC_SDMMC1CLKSOURCE_CLK48;  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)  {    Error_Handler();  }}

/*** @brief  Main program* @param  None* @retval int*/int main(void){       /* STM32F4xx HAL library initialization:  - Configure the Flash ART accelerator on ITCM interface  - Configure the Systick to generate an interrupt each 1 msec  - Set NVIC Group Priority to 4  - Global MSP (MCU Support Package) initialization  */#ifdef INCLUDE_THIRD_PARTY_MODULE    /* Code Need to handle third party module */    __HAL_RCC_RTC_ENABLE();  __HAL_RCC_PWR_CLK_ENABLE();  __HAL_RCC_BKPSRAM_CLK_ENABLE();     HAL_PWR_EnableBkUpAccess();  if(*(__IO uint32_t *)(0x40024000) == GFX_DEMO_SIGNATURE_A)  {    *(__IO uint32_t *)(0x40024000) = 0;        /* Reinitialize the Stack pointer*/    __set_MSP(*(__IO uint32_t*) GFX_DEMO_ADDRESS);    /* jump to application address */      ((pFunc) (*(__IO uint32_t*) (GFX_DEMO_ADDRESS + 4)))();  }#endif    HAL_Init();    /* Configure the system clock @ 180 Mhz */  SystemClock_Config();  k_BspInit();     /* Initialize RTC */  k_CalendarBkupInit();        /* Create GUI task */  osThreadDef(GUI_Thread, GUIThread, osPriorityNormal, 0, 2048);  osThreadCreate (osThread(GUI_Thread), NULL);     /* Add Modules*/  k_ModuleInit();    /* Link modules */   k_ModuleAdd(&audio_player_board);         k_ModuleAdd(&video_player_board);    k_ModuleAdd(&games_board);  k_ModuleAdd(&audio_recorder_board);  #ifdef INCLUDE_THIRD_PARTY_MODULE  k_ModuleAdd(&third_party_board);#else  k_ModuleAdd(&gardening_control_board);   #endif       k_ModuleAdd(&home_alarm_board);   k_ModuleAdd(&settings_board);  /* Initialize GUI */  GUI_Init();       WM_MULTIBUF_Enable(1);  GUI_SetLayerVisEx (1, 0);  GUI_SelectLayer(0);    GUI_SetBkColor(GUI_WHITE);  GUI_Clear();     /* Start scheduler */  osKernelStart ();  /* We should never get here as control is now taken by the scheduler */  for( ;; );}

void RTC_Init(void){  RTC_DateTypeDef DateToUpdate;	    HAL_PWR_EnableBkUpAccess();    /* Enable BKP CLK enable for backup registers */    __HAL_RCC_BKP_CLK_ENABLE();    /* Peripheral clock enable */    __HAL_RCC_RTC_ENABLE();    /* Peripheral interrupt init */    HAL_NVIC_SetPriority(RTC_IRQn, 0, 0);    HAL_NVIC_EnableIRQ(RTC_IRQn);    HAL_NVIC_SetPriority(RTC_Alarm_IRQn, 0, 0);    HAL_NVIC_EnableIRQ(RTC_Alarm_IRQn);		    /**Initialize RTC and set the Time and Date     */		hrtc.Instance = RTC;		hrtc.Init.AsynchPrediv = RTC_AUTO_1_SECOND;		hrtc.Init.OutPut = RTC_OUTPUTSOURCE_NONE;		HAL_RTC_Init(&hrtc);	if (HAL_RTCEx_BKUPRead(&hrtc, 1) != RTC_IS_SET)		{// check RTC is init or no			HAL_RTC_GetDate(&hrtc, &DateToUpdate, RTC_FORMAT_BCD);						if (DateToUpdate.Year == 0x0)			{					sTime.Hours = 0x20;					sTime.Minutes = 0x10;					sTime.Seconds = 0;					//HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BCD);					DateToUpdate.WeekDay = RTC_WEEKDAY_THURSDAY;					DateToUpdate.Month = RTC_MONTH_AUGUST;					DateToUpdate.Date = 0x11;					DateToUpdate.Year = 0x16;										//HAL_RTC_SetDate(&hrtc, &DateToUpdate, RTC_FORMAT_BCD);				//directly write to counter						//		if(something == 1)//		{//			something = 0;//			while ((hrtc.Instance->CRL | RTC_CRL_RTOFF) == 0);//			hrtc.Instance->CRL |= RTC_CRL_CNF;//			hrtc.Instance->CNTL = 0xD63C;//			hrtc.Instance->CNTH = 0x57DF;//			hrtc.Instance->CRL &= ~RTC_CRL_CNF;//		}			}			HAL_RTCEx_BKUPWrite(&hrtc, 1, RTC_IS_SET);		}				HAL_RTCEx_SetSecond_IT(&hrtc);	}

void rtc_init(void){    RCC_OscInitTypeDef RCC_OscInitStruct;    uint32_t rtc_freq = 0;#if DEVICE_RTC_LSI    if (rtc_inited) return;    rtc_inited = 1;#endif    RtcHandle.Instance = RTC;#if !DEVICE_RTC_LSI    // Enable LSE Oscillator    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_LSE;    RCC_OscInitStruct.PLL.PLLState   = RCC_PLL_NONE; // Mandatory, otherwise the PLL is reconfigured!    RCC_OscInitStruct.LSEState       = RCC_LSE_ON; // External 32.768 kHz clock on OSC_IN/OSC_OUT    RCC_OscInitStruct.LSIState       = RCC_LSI_OFF;    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) == HAL_OK) { // Check if LSE has started correctly        // Connect LSE to RTC        __HAL_RCC_RTC_CLKPRESCALER(RCC_RTCCLKSOURCE_LSE);        __HAL_RCC_RTC_CONFIG(RCC_RTCCLKSOURCE_LSE);        rtc_freq = LSE_VALUE;    } else {	    error("Cannot initialize RTC with LSE/n");    }#else	    // Enable Power clock    __PWR_CLK_ENABLE();    // Enable access to Backup domain    HAL_PWR_EnableBkUpAccess();    // Reset Backup domain    __HAL_RCC_BACKUPRESET_FORCE();    __HAL_RCC_BACKUPRESET_RELEASE();	// Enable LSI clock	RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_LSE;	RCC_OscInitStruct.PLL.PLLState   = RCC_PLL_NONE; // Mandatory, otherwise the PLL is reconfigured!	RCC_OscInitStruct.LSEState       = RCC_LSE_OFF;	RCC_OscInitStruct.LSIState       = RCC_LSI_ON;	if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {		error("Cannot initialize RTC with LSI/n");	}	// Connect LSI to RTC    __HAL_RCC_RTC_CLKPRESCALER(RCC_RTCCLKSOURCE_LSI);    __HAL_RCC_RTC_CONFIG(RCC_RTCCLKSOURCE_LSI);	// This value is LSI typical value. To be measured precisely using a timer input capture for example.	rtc_freq = 40000;#endif    // Enable RTC    __HAL_RCC_RTC_ENABLE();    RtcHandle.Init.HourFormat     = RTC_HOURFORMAT_24;#ifdef TARGET_MOTE_L152RC    /* SubSecond resolution of 16384Hz */    RtcHandle.Init.AsynchPrediv   = 1;    RtcHandle.Init.SynchPrediv    = (rtc_freq / 2) - 1;#else    RtcHandle.Init.AsynchPrediv   = 127;    RtcHandle.Init.SynchPrediv    = (rtc_freq / 128) - 1;#endif    RtcHandle.Init.OutPut         = RTC_OUTPUT_DISABLE;    RtcHandle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;    RtcHandle.Init.OutPutType     = RTC_OUTPUT_TYPE_OPENDRAIN;    if (HAL_RTC_Init(&RtcHandle) != HAL_OK) {        error("RTC error: RTC initialization failed.");    }}