// Simply print to the debug console a string based on the type of reset. // ============================================================================ void vDebugPrintResetType( void ) { if ( PWR_GetFlagStatus( PWR_FLAG_WU ) ) vDebugPrintf( "PWR: Wake Up flag\r\n" ); if ( PWR_GetFlagStatus( PWR_FLAG_SB ) ) vDebugPrintf( "PWR: StandBy flag.\r\n" ); if ( PWR_GetFlagStatus( PWR_FLAG_PVDO ) ) vDebugPrintf( "PWR: PVD Output.\r\n" ); if ( PWR_GetFlagStatus( PWR_FLAG_BRR ) ) vDebugPrintf( "PWR: Backup regulator ready flag.\r\n" ); if ( PWR_GetFlagStatus( PWR_FLAG_REGRDY ) ) vDebugPrintf( "PWR: Main regulator ready flag.\r\n" ); if ( RCC_GetFlagStatus( RCC_FLAG_BORRST ) ) vDebugPrintf( "RCC: POR/PDR or BOR reset\r\n" ); if ( RCC_GetFlagStatus( RCC_FLAG_PINRST ) ) vDebugPrintf( "RCC: Pin reset.\r\n" ); if ( RCC_GetFlagStatus( RCC_FLAG_PORRST ) ) vDebugPrintf( "RCC: POR/PDR reset.\r\n" ); if ( RCC_GetFlagStatus( RCC_FLAG_SFTRST ) ) vDebugPrintf( "RCC: Software reset.\r\n" ); if ( RCC_GetFlagStatus( RCC_FLAG_IWDGRST ) ) vDebugPrintf( "RCC: Independent Watchdog reset.\r\n" ); if ( RCC_GetFlagStatus( RCC_FLAG_WWDGRST ) ) vDebugPrintf( "RCC: Window Watchdog reset.\r\n" ); if ( RCC_GetFlagStatus( RCC_FLAG_LPWRRST ) ) vDebugPrintf( "RCC: Low Power reset.\r\n" ); }
void PVDTset() { RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); PWR_PVDLevelConfig(PWR_PVDLevel_2V8); //PWR_PVDLevelConfig(PWR_PVDLevel_2V6); PWR_PVDCmd(ENABLE); while(1) { if(PWR_GetFlagStatus(PWR_FLAG_PVDO)) { uart_printf("VDD<2.8V=PWR->CSR\r\n"); break; } } uart_printf("PWR->CSR=0x%x\r\n",PWR->CSR); while(1) { if(PWR_GetFlagStatus(PWR_FLAG_PVDO)==0) { uart_printf("VDD>2.8V=PWR->CSR\r\n"); break; } } }
void RTC_Config(void) { /*后备寄存器1中,存了一个特殊字符0xA5A5 第一次上电或后备电源掉电后,该寄存器数据丢失, 表明RTC数据丢失,需要重新配置 */ if(BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5) //检查是否第一次上电或后备电池已经掉电, { Write_Log("Backup VBAT PowerDown or First time PowerUp,Initialize RTC\r\n"); RTC_Configuration(); BKP_WriteBackupRegister(BKP_DR1, 0xA5A5); time_now.tm_year = 2011; time_now.tm_mon = 10; //月份表示为0~11 time_now.tm_mday = 13; time_now.tm_hour = 13; time_now.tm_min = 16; time_now.tm_sec = 38; Time_SetCalendarTime(time_now);//设置初始时间 } else //若后备寄存器没有掉电,则无需重新配置RTC { Write_Log("Backup VBAT Keep, Don't RTC Configuralation\r\n"); //等待RTC与APB同步 RTC_WaitForSynchro(); RTC_WaitForLastTask(); //使能秒中断 RTC_ITConfig(RTC_IT_SEC, ENABLE); RTC_WaitForLastTask(); } //这里我们可以利用RCC_GetFlagStatus()函数查看本次复位类型 if (RCC_GetFlagStatus(RCC_FLAG_PORRST) != RESET) { por_rst_flag = 1; Write_Log("PowerUp Reset\r\n"); } else if (RCC_GetFlagStatus(RCC_FLAG_PINRST) != RESET) { pin_rst_flag = 1; Write_Log("pin Reset\r\n"); } else if(PWR_GetFlagStatus(PWR_FLAG_WU)!= RESET) //wakeup唤醒 { Write_Log("WakeUp...\r\n"); } if(PWR_GetFlagStatus(PWR_FLAG_SB) != RESET) //检查是否由待机模式下唤醒,如是则不需要配置RTC /* System resumed from STANDBY mode */ /* Clear StandBy flag */ PWR_ClearFlag(PWR_FLAG_SB); //清除RCC中复位标志 RCC_ClearFlag(); return; }
/******************************************************************************* * Function Name : RTCAlarm_IRQHandler * Description : This function handles RTC Alarm interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void RTCAlarm_IRQHandler(void) { if(RTC_GetITStatus(RTC_IT_ALR) != RESET) { SPARK_WLAN_SLEEP = 0; /* Clear EXTI line17 pending bit */ EXTI_ClearITPendingBit(EXTI_Line17); /* Check if the Wake-Up flag is set */ if(PWR_GetFlagStatus(PWR_FLAG_WU) != RESET) { /* Clear Wake Up flag */ PWR_ClearFlag(PWR_FLAG_WU); } /* Wait until last write operation on RTC registers has finished */ RTC_WaitForLastTask(); /* Clear RTC Alarm interrupt pending bit */ RTC_ClearITPendingBit(RTC_IT_ALR); /* Wait until last write operation on RTC registers has finished */ RTC_WaitForLastTask(); } }
int HAL_Feature_Set(HAL_Feature feature, bool enabled) { switch (feature) { case FEATURE_RETAINED_MEMORY: { FunctionalState state = enabled ? ENABLE : DISABLE; // Switch on backup SRAM clock // Switch on backup power regulator, so that it survives the deep sleep mode, // software and hardware reset. Power must be supplied to VIN or VBAT to retain SRAM values. PWR_BackupRegulatorCmd(state); // Wait until backup power regulator is ready, should be fairly instantaneous... but timeout in 10ms. if (state == ENABLE) { system_tick_t start = HAL_Timer_Get_Milli_Seconds(); while (PWR_GetFlagStatus(PWR_FLAG_BRR) == RESET) { if (HAL_Timer_Get_Milli_Seconds() - start > 10UL) { return -2; } }; } return 0; } } return -1; }
/** * @brief Enters MCU in STANDBY mode. The wake-up from STANDBY mode is performed * when a rising edge is detected on WakeUp pin. * @param None * @retval None */ void LowPower_EnterSTANDBYMode_WAKEUP_1(void) { // LCD_Clear(LCD_COLOR_WHITE); /* Set the LCD Back Color */ // LCD_SetBackColor(LCD_COLOR_BLUE); /* Set the LCD Text Color */ // LCD_SetTextColor(LCD_COLOR_WHITE); // LCD_DisplayStringLine(LCD_LINE_7, " MCU in STANDBY Mode"); // LCD_DisplayStringLine(LCD_LINE_8, " To exit press SEL "); /* Check if the StandBy flag is set */ if (PWR_GetFlagStatus(PWR_FLAG_SB) != RESET) { /* Clear StandBy flag */ PWR_ClearFlag(PWR_FLAG_SB); RTC_WaitForSynchro(); } RTC_AlarmCmd(RTC_Alarm_A, DISABLE); /* Enable WakeUp pin */ PWR_WakeUpPinCmd(PWR_WakeUpPin_1, ENABLE); /* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */ PWR_EnterSTANDBYMode(); }
/** * @brief Main program. * @param None * @retval None */ int main(void) { /*!< At this stage the microcontroller clock setting is already configured, this is done through SystemInit() function which is called from startup file (startup_stm32f30x.s) before to branch to application main. To reconfigure the default setting of SystemInit() function, refer to system_stm32f30x.c file */ /* PVD configuration */ PWR_Config(); /* SYSCFG configuration */ SYSCFG_Config(); /* TIM1 channels Configuration in PWM mode */ TIM_Config(); /* Wait till a PVD event is detected */ while(PWR_GetFlagStatus(PWR_FLAG_PVDO) == RESET); /* Infinite loop */ while (1) { } }
bool HAL_Feature_Get(HAL_Feature feature) { switch (feature) { // Warm Start: active when resuming from Standby mode (deep sleep) case FEATURE_WARM_START: { return (PWR_GetFlagStatus(PWR_FLAG_SB) != RESET); } // Retained Memory: active when backup regulator is enabled case FEATURE_RETAINED_MEMORY: { return (PWR_GetFlagStatus(PWR_FLAG_BRR) != RESET); } } return false; }
/** * @brief Selects HSE as System clock source and configure HCLK, PCLK2 and PCLK1 prescalers. * @param None * @retval None */ void SetHCLKTo8(void) { /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration -----------------------------*/ /* RCC system reset(for debug purpose) */ RCC_DeInit(); /* Enable HSE */ RCC_HSEConfig(RCC_HSE_ON); /* Wait till HSE is ready */ HSEStartUpStatus = RCC_WaitForHSEStartUp(); if (HSEStartUpStatus == SUCCESS) { /* Flash 0 wait state */ FLASH_SetLatency(FLASH_Latency_0); /* Disable Prefetch Buffer */ FLASH_PrefetchBufferCmd(DISABLE); /* Disable 64-bit access */ FLASH_ReadAccess64Cmd(DISABLE); /* Enable the PWR APB1 Clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); /* Select the Voltage Range 2 (1.5V) */ PWR_VoltageScalingConfig(PWR_VoltageScaling_Range2); /* Wait Until the Voltage Regulator is ready */ while (PWR_GetFlagStatus(PWR_FLAG_VOS) != RESET) {} /* HCLK = SYSCLK */ RCC_HCLKConfig(RCC_SYSCLK_Div1); /* PCLK2 = HCLK */ RCC_PCLK2Config(RCC_HCLK_Div1); /* PCLK1 = HCLK */ RCC_PCLK1Config(RCC_HCLK_Div1); /* Select HSE as system clock source */ RCC_SYSCLKConfig(RCC_SYSCLKSource_HSE); /* Wait till HSE is used as system clock source */ while (RCC_GetSYSCLKSource() != 0x08) {} } else { /* If HSE fails to start-up, the application will have wrong clock configuration. User can add here some code to deal with this error */ /* Go to infinite loop */ while (1) {} } }
/** * @brief To select MSI as System clock source * @caller ADC_Icc_Test * @param Frequence, DIV by 2 ot not , With or without RTC * @retval None */ void SetHSICLKToMSI(uint32_t freq,bool div2,bool With_RTC) { /* RCC system reset */ RCC_DeInit(); /* Flash 1 wait state */ FLASH_SetLatency(FLASH_Latency_0); /* Disable Prefetch Buffer */ FLASH_PrefetchBufferCmd(DISABLE); /* Disable 64-bit access */ FLASH_ReadAccess64Cmd(DISABLE); /* Disable FLASH during SLeep */ FLASH_SLEEPPowerDownCmd(ENABLE); /* Enable the PWR APB1 Clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); /* Select the Voltage Range 3 (1.2V) */ PWR_VoltageScalingConfig(PWR_VoltageScaling_Range3); /* Wait Until the Voltage Regulator is ready */ while (PWR_GetFlagStatus(PWR_FLAG_VOS) != RESET) {} /* To configure the MSI frequency */ RCC_MSIRangeConfig(freq); /* Select MSI as system clock source */ RCC_SYSCLKConfig(RCC_SYSCLKSource_MSI); /* Wait till MSI is used as system clock source */ while (RCC_GetSYSCLKSource() != 0x00) {} if (div2) { RCC_HCLKConfig(RCC_SYSCLK_Div2); } RCC_HSICmd(DISABLE); /* Disable HSE clock */ RCC_HSEConfig(RCC_HSE_OFF); /* Disable LSE clock */ if (! With_RTC) RCC_LSEConfig(RCC_LSE_OFF); /* Disable LSI clock */ RCC_LSICmd(DISABLE); }
/** * @brief Enters MCU in STANDBY mode. The wake-up from STANDBY mode is performed * by an RTC Alarm event. * @param None * @retval None */ void LowPower_EnterSTANDBYMode_RTCAlarm(void) { // LCD_Clear(LCD_COLOR_WHITE); /* Set the LCD Back Color */ // LCD_SetBackColor(LCD_COLOR_BLUE); /* Set the LCD Text Color */ // LCD_SetTextColor(LCD_COLOR_WHITE); /* External Interrupt Disable */ //Demo_IntExtOnOffCmd(DISABLE); /* Enable WakeUp pin */ PWR_WakeUpPinCmd(PWR_WakeUpPin_1, ENABLE); /* Check if the StandBy flag is set */ if (PWR_GetFlagStatus(PWR_FLAG_SB) != RESET) { /* Clear StandBy flag */ PWR_ClearFlag(PWR_FLAG_SB); RTC_WaitForSynchro(); } if (RTC_ReadBackupRegister(RTC_BKP_DR0) != 0x5AA5) { // LCD_DisplayStringLine(LCD_LINE_1, "Time and Date are "); // LCD_DisplayStringLine(LCD_LINE_2, "not configured, "); // LCD_DisplayStringLine(LCD_LINE_3, "please go to the "); // LCD_DisplayStringLine(LCD_LINE_4, "calendar menu and "); // LCD_DisplayStringLine(LCD_LINE_5, "set the time and "); // LCD_DisplayStringLine(LCD_LINE_6, "date parameters. "); // LCD_DisplayStringLine(LCD_LINE_7, "Press JoyStick to "); // LCD_DisplayStringLine(LCD_LINE_8, "continue... "); /* External Interrupt Enable */ //Demo_IntExtOnOffCmd(ENABLE); return; } Calendar_AlarmPreAdjust_A(); // LCD_DisplayStringLine(LCD_LINE_7, " MCU in STANDBY Mode"); // LCD_DisplayStringLine(LCD_LINE_8, " Wait For RTC Alarm "); /* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */ PWR_EnterSTANDBYMode(); }
/** * @brief Configures RTC clock source and prescaler. * @param None * @retval None */ void RTC_Configuration(void) { /* Check if the StandBy flag is set */ if(PWR_GetFlagStatus(PWR_FLAG_SB) != RESET) {/* System resumed from STANDBY mode */ /* Turn on LD4 */ STM32vldiscovery_LEDOn(LED4); /* Clear StandBy flag */ PWR_ClearFlag(PWR_FLAG_SB); /* Wait for RTC APB registers synchronisation */ RTC_WaitForSynchro(); /* No need to configure the RTC as the RTC configuration(clock source, enable, prescaler,...) is kept after wake-up from STANDBY */ } else {/* StandBy flag is not set */ /* RTC clock source configuration ----------------------------------------*/ /* Reset Backup Domain */ BKP_DeInit(); /* Enable LSE OSC */ RCC_LSEConfig(RCC_LSE_ON); /* Wait till LSE is ready */ while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) { } /* Select the RTC Clock Source */ RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE); /* Enable the RTC Clock */ RCC_RTCCLKCmd(ENABLE); /* RTC configuration -----------------------------------------------------*/ /* Wait for RTC APB registers synchronisation */ RTC_WaitForSynchro(); /* Set the RTC time base to 1s */ RTC_SetPrescaler(32767); /* Wait until last write operation on RTC registers has finished */ RTC_WaitForLastTask(); } }
void BKPSRAM_Init(void) { /* Enable PWR clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); /* Enable backup SRAM Clock */ RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_BKPSRAM, ENABLE); /* Allow access to backup domain */ PWR_BackupAccessCmd(ENABLE); /* Enable the Backup SRAM low power Regulator */ /* This will allow data to stay when using VBat mode */ PWR_BackupRegulatorCmd(ENABLE); /* Wait for backup regulator to be ready */ while (PWR_GetFlagStatus(PWR_FLAG_BRR) == RESET); }
void Platform_Init(void) { /*STM32 wakeup by watchdog in standby mode, re-enter standby mode in this situation*/ PlatformWDGReload(); if ( (PWR_GetFlagStatus(PWR_FLAG_SB) != RESET) && RCC_GetFlagStatus(RCC_FLAG_IWDGRST) != RESET) { RCC_ClearFlag(); Platform_Enter_STANDBY(); } PWR_ClearFlag(PWR_FLAG_SB); mico_rtos_init_mutex(&printf_mutex); Platform_Button_EL_Init(); Platform_Button_STANDBY_Init(); Platform_LED_SYS_Init(); Platform_LED_RF_Init(); Platform_Debug_UART_Init(); }
static void Init_Last_Reset_Info() { if (HAL_Core_System_Reset_FlagSet(SOFTWARE_RESET)) { // Load reset info from backup registers last_reset_info.reason = BKP_ReadBackupRegister(BKP_DR2); const uint16_t hi = BKP_ReadBackupRegister(BKP_DR3); const uint16_t lo = BKP_ReadBackupRegister(BKP_DR4); last_reset_info.data = ((uint32_t)hi << 16) | (uint32_t)lo; // Clear backup registers BKP_WriteBackupRegister(BKP_DR2, 0); BKP_WriteBackupRegister(BKP_DR3, 0); BKP_WriteBackupRegister(BKP_DR4, 0); } else // Hardware reset { if (HAL_Core_System_Reset_FlagSet(WATCHDOG_RESET)) { last_reset_info.reason = RESET_REASON_WATCHDOG; } else if (HAL_Core_System_Reset_FlagSet(POWER_MANAGEMENT_RESET)) { last_reset_info.reason = RESET_REASON_POWER_MANAGEMENT; // Reset generated when entering standby mode (nRST_STDBY: 0) } else if (HAL_Core_System_Reset_FlagSet(POWER_DOWN_RESET)) { last_reset_info.reason = RESET_REASON_POWER_DOWN; } else if (HAL_Core_System_Reset_FlagSet(PIN_RESET)) // Pin reset flag should be checked in the last place { last_reset_info.reason = RESET_REASON_PIN_RESET; } else if (PWR_GetFlagStatus(PWR_FLAG_SB) != RESET) // Check if MCU was in standby mode { last_reset_info.reason = RESET_REASON_POWER_MANAGEMENT; // Reset generated when exiting standby mode (nRST_STDBY: 1) } else { last_reset_info.reason = RESET_REASON_UNKNOWN; } last_reset_info.data = 0; // Not used } // Note: RCC reset flags should be cleared, see HAL_Core_Init() }
/** * @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 Pin1 (PA.00) * @param None * @retval None */ void StandbyMode_Measure(void) { /* Check if the StandBy flag is set */ if (PWR_GetFlagStatus(PWR_FLAG_SB) != RESET) { /* Clear StandBy flag */ PWR_ClearFlag(PWR_FLAG_SB); } /* Enable WKUP pin 1 */ PWR_WakeUpPinCmd(PWR_WakeUpPin_1,ENABLE); /* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */ PWR_EnterSTANDBYMode(); /* Infinite loop */ while (1) { } }
/**************************************************************************** * 名 称:void clock_ini(void) * 功 能:时钟初始化函数 * 入口参数:无 * 出口参数:无 * 说 明: * 调用方法: ****************************************************************************/ void clock_ini(void) { #if defined (STOP_Mode) if(BKP_CheckLOCK_RTC() != BKP_RTC_Flag){ RTC_Configuration(); RTC_InitStructure.RTC_AsynchPrediv = AsynchPrediv; RTC_InitStructure.RTC_SynchPrediv = SynchPrediv; RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24; while(RTC_Init(&RTC_InitStructure) == ERROR) {} Set_Time(time); BKP_LOCK_RTC(); }else{ while(RCC_GetFlagStatus(RCC_FLAG_PORRST) == RESET) {} while(RCC_GetFlagStatus(RCC_FLAG_PINRST) == RESET) {} RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); PWR_RTCAccessCmd(ENABLE); RTC_WaitForSynchro(); } RTC_Alarm_Exit(); RTC_NVIC_Configuration(); RTC_ClearFlag(RTC_FLAG_ALRAF); PWR_ClearFlag(PWR_FLAG_WU); #elif defined (TANDBY_Mode) RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); PWR_RTCAccessCmd(ENABLE); PWR_ClearFlag(PWR_FLAG_WU); if(PWR_GetFlagStatus(PWR_FLAG_SB) != RESET) { PWR_ClearFlag(PWR_FLAG_SB); RTC_WaitForSynchro(); }else { RTC_Configuration(); RTC_InitStructure.RTC_AsynchPrediv = AsynchPrediv; RTC_InitStructure.RTC_SynchPrediv = SynchPrediv; RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24; while(RTC_Init(&RTC_InitStructure) == ERROR) {} Set_Time(time); RTC_ClearFlag(RTC_FLAG_ALRAF); } #endif }
/** * @brief Selects MSI (64KHz) as System clock source and configure * HCLK, PCLK2 and PCLK1 prescalers. * @param None * @retval None */ void SetHCLKToMSI_64KHz(void) { /* RCC system reset */ RCC_DeInit(); /* Flash 0 wait state */ FLASH_SetLatency(FLASH_Latency_0); /* Disable Prefetch Buffer */ FLASH_PrefetchBufferCmd(DISABLE); /* Disable 64-bit access */ FLASH_ReadAccess64Cmd(DISABLE); /* Enable the PWR APB1 Clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); /* Select the Voltage Range 3 (1.2V) */ PWR_VoltageScalingConfig(PWR_VoltageScaling_Range3); /* Wait Until the Voltage Regulator is ready */ while (PWR_GetFlagStatus(PWR_FLAG_VOS) != RESET) {} /* HCLK = SYSCLK */ RCC_HCLKConfig(RCC_SYSCLK_Div1); /* PCLK2 = HCLK */ RCC_PCLK2Config(RCC_HCLK_Div1); /* PCLK1 = HCLK */ RCC_PCLK1Config(RCC_HCLK_Div1); /* Set MSI clock range to 64KHz */ RCC_MSIRangeConfig(RCC_MSIRange_0); /* Select MSI as system clock source */ RCC_SYSCLKConfig(RCC_SYSCLKSource_MSI); /* Wait till PLL is used as system clock source */ while (RCC_GetSYSCLKSource() != 0x00) {} }
void RTC_Alarm_irq(void) { if(RTC_GetITStatus(RTC_IT_ALRA) != RESET) { HAL_RTCAlarm_Handler(); /* Clear EXTI line17 pending bit */ EXTI_ClearITPendingBit(EXTI_Line17); /* Check if the Wake-Up flag is set */ if(PWR_GetFlagStatus(PWR_FLAG_WU) != RESET) { /* Clear Wake Up flag */ PWR_ClearFlag(PWR_FLAG_WU); } /* Clear RTC Alarm interrupt pending bit */ RTC_ClearITPendingBit(RTC_IT_ALRA); } }
/** * @brief Selects MSI (Default Value, 2MHz) as System clock source and configure * HCLK, PCLK2 and PCLK1 prescalers. * @param None * @retval None */ void SetHCLKToMSI_2MHz(void) { /* RCC system reset */ RCC_DeInit(); /* Flash 0 wait state */ FLASH_SetLatency(FLASH_Latency_0); /* Disable Prefetch Buffer */ FLASH_PrefetchBufferCmd(DISABLE); /* Disable 64-bit access */ FLASH_ReadAccess64Cmd(DISABLE); /* Enable the PWR APB1 Clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); /* Select the Voltage Range 3 (1.2V) */ PWR_VoltageScalingConfig(PWR_VoltageScaling_Range3); /* Wait Until the Voltage Regulator is ready */ while (PWR_GetFlagStatus(PWR_FLAG_VOS) != RESET) {} }
/** * @brief Main program. * @param None * @retval None */ int main(void) { /*!< At this stage the microcontroller clock setting is already configured, this is done through SystemInit() function which is called from startup file (startup_stm32f0xx.s) before to branch to application main. To reconfigure the default setting of SystemInit() function, refer to system_stm32f0xx.c file */ /* PWR clock enable */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); /* PVD configuration: Level 5 */ PWR_PVDLevelConfig(PWR_PVDLevel_5); /* Enable the Power Voltage Detector(PVD) */ PWR_PVDCmd(ENABLE); /* Enable SYSCFG clock */ RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE); /* Connect PVD event with BKIN: when a PVD event (VDD lower than the threshold) is detected a break event is generated */ SYSCFG_BreakConfig(SYSCFG_Break_PVD); /* TIM1 channels Configuration in PWM mode */ TIM_Config(); /* Wait till a PVD event is detected */ while(PWR_GetFlagStatus(PWR_FLAG_PVDO) == RESET); /* Infinite loop */ while (1) { } }
/** * @brief Main program * @param None * @retval None */ int main(void) { /*!< At this stage the microcontroller clock setting is already configured, this is done through SystemInit() function which is called from startup files (startup_stm32f40_41xxx.s/startup_stm32f427_437xx.s) before to branch to application main. To reconfigure the default setting of SystemInit() function, refer to system_stm32f4xx.c file */ /* Enable PWR APB1 Clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); /* Allow access to Backup */ PWR_BackupAccessCmd(ENABLE); /* Reset RTC Domain */ RCC_BackupResetCmd(ENABLE); RCC_BackupResetCmd(DISABLE); /* Check that the system was resumed from StandBy mode */ if(PWR_GetFlagStatus(PWR_FLAG_SB) != RESET) { /* Clear SB Flag */ PWR_ClearFlag(PWR_FLAG_SB); /* Initialize LED1 on STM324xG-EVAL board */ STM_EVAL_LEDInit(LED1); /* Infinite loop */ while (1) { /* Toggle The LED1 */ STM_EVAL_LEDToggle(LED1); /* Inserted Delay */ for(uwCounter = 0; uwCounter < 0x5FFFF; uwCounter++); } } /* Configure Key Button */ STM_EVAL_PBInit(BUTTON_KEY,BUTTON_MODE_GPIO); /* Wait until Key button is pressed to enter the Low Power mode */ while(STM_EVAL_PBGetState(BUTTON_KEY) != RESET) { } /* Loop while Key button is maintained pressed */ while(STM_EVAL_PBGetState(BUTTON_KEY) == RESET) { } #if defined (SLEEP_MODE) /* Sleep Mode Entry - System Running at PLL (168MHz) - Flash 5 wait state - Instruction and Data caches ON - Prefetch ON - Code running from Internal FLASH - All peripherals disabled. - Wakeup using EXTI Line (Key Button PG.15) */ SleepMode_Measure(); #elif defined (STOP_MODE) /* STOP Mode Entry - RTC Clocked by LSE/LSI - Regulator in LP mode - HSI, HSE OFF and LSI OFF if not used as RTC Clock source - No IWDG - FLASH in deep power down mode - Automatic Wakeup using RTC clocked by LSE/LSI (after ~20s) */ StopMode_Measure(); #elif defined (STANDBY_MODE) /* STANDBY Mode Entry - Backup SRAM and RTC OFF - IWDG and LSI OFF - Wakeup using WakeUp Pin (PA.00) */ StandbyMode_Measure(); #elif defined (STANDBY_RTC_MODE) /* STANDBY Mode with RTC on LSE/LSI Entry - RTC Clocked by LSE or LSI - IWDG OFF and LSI OFF if not used as RTC Clock source - Backup SRAM OFF - Automatic Wakeup using RTC clocked by LSE/LSI (after ~20s) */ StandbyRTCMode_Measure(); #elif defined (STANDBY_RTC_BKPSRAM_MODE) /* STANDBY Mode with RTC on LSE/LSI Entry - RTC Clocked by LSE/LSI - Backup SRAM ON - IWDG OFF - Automatic Wakeup using RTC clocked by LSE/LSI (after ~20s) */ StandbyRTCBKPSRAMMode_Measure(); #else /* Initialize LED1 on STM324xG-EVAL board */ STM_EVAL_LEDInit(LED1); /* Infinite loop */ while (1) { /* Toggle The LED1 */ STM_EVAL_LEDToggle(LED1); /* Inserted Delay */ for(Counter = 0; Counter < 0x5FF; Counter++); } #endif }
int main(void) { RCC_APB1PeriphClockCmd( RCC_APB1Periph_PWR, ENABLE);//!!!! // тактирование ядра низкоскоростным внутренним генератором 4мгц RCC->ICSCR &= ~RCC_ICSCR_MSIRANGE;//!!!! RCC->ICSCR |= RCC_ICSCR_MSIRANGE_6;//!!!! //RTC_Initilithahion();//!!!! //////////////////////////////////////////////////////////////////// delay_ms(1000);//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! curent_cmd = 0; PCount_Start = 0; /////////////////// настройка пробуждения RCC_HSICmd(DISABLE); PWR_PVDCmd(DISABLE); PWR_UltraLowPowerCmd(ENABLE); PWR_WakeUpPinCmd(PWR_WakeUpPin_1,ENABLE); PWR_UltraLowPowerCmd(ENABLE); ////////////// настройка прирывания для будильника в неспящем режиме EXTI_InitTypeDef exti; NVIC_InitTypeDef NVIC_InitStructure; EXTI_ClearITPendingBit(EXTI_Line17); exti.EXTI_Line = EXTI_Line17; exti.EXTI_Mode = EXTI_Mode_Interrupt; exti.EXTI_Trigger = EXTI_Trigger_Rising; exti.EXTI_LineCmd = ENABLE; EXTI_Init(&exti); NVIC_InitStructure.NVIC_IRQChannel = RTC_Alarm_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); ////////////////// if(PWR_GetFlagStatus(PWR_FLAG_SB)!=RESET)//Если МК вышел из режима standby { WkupFlag=1; curent_cmd = 1; if(RTC_GetFlagStatus(RTC_FLAG_ALRAF)!=RESET)//Если МК вышел из режима ALARM { //RTC_Initilithahion();//!!!! //PWR_RTCAccessCmd(ENABLE); //RTC_ClearFlag(RTC_FLAG_ALRAF); //PWR_RTCAccessCmd(DISABLE); //f_WakeupToAlarm=1; curent_cmd = 5; } //RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR,ENABLE); PWR_ClearFlag(PWR_FLAG_SB); //Сброс флага, который указывает на то, что МК вышел из режима standby PWR_RTCAccessCmd(ENABLE); // Доступ в RTC //RTC_ClearITPendingBit(RTC_IT_WUT); //RTC_ClearFlag(RTC_FLAG_WUTF); RTC_ClearFlag(RTC_FLAG_ALRAF); PWR_RTCAccessCmd(DISABLE); } else { WkupFlag=0; RTC_TimeTypeDef alarmTime; alarmTime.RTC_H12 = RTC_H12_PM;//!!!!; alarmTime.RTC_Hours = 20; alarmTime.RTC_Minutes = 0; alarmTime.RTC_Seconds = 20; RTC_Initilithahion();//!!!! //RTC_Set_Alarm(alarmTime);/// Магическая последовательность, 1. RTC_Set_Alarm, 2. RTC_Set_Time иначе не работает будильник RTC_TimeTypeDef RTC_Time; RTC_DateTypeDef RTC_Date; RTC_Time.RTC_H12 = RTC_H12_PM;//!!!!; RTC_Time.RTC_Hours = 20; RTC_Time.RTC_Minutes = 00; RTC_Time.RTC_Seconds = 00; RTC_Date.RTC_WeekDay = RTC_Weekday_Sunday; RTC_Date.RTC_Year = 14; RTC_Date.RTC_Month = 8; RTC_Date.RTC_Date = 17; RTC_Set_TimeDate(RTC_Time, RTC_Date);/// } //else curent_cmd = 0;//f_WakeupToAlarm=0; //RTC_Initilithahion();//!!!! //RTC_Set_Time(); OLED_Init(); OLED_Clear(); char i,j; /* RCC_GetClocksFreq(&Frequency); f=Frequency.SYSCLK_Frequency/1000; IntToStr(a,f); OLED_DrawString_fast(30,30,a,10); */ OLED_LcdCache_Clear(); //if(0==WkupFlag) //Если МК до этого не находился в режиме STANDBY!!!!!!!!!!!!!!!!! //PWR_EnterSTANDBYMode(); //Перейди в режим STANDBY!!!!!!!!!!!!!!!!!!! //OLED_DrawBitmap_fast(3,12,menu1_sprait,123,40); //delay_ms(10000); WaitToSleep = 0; TACT_Config(); BackTimeAndData.hour=0; BackTimeAndData.minute=0; BackTimeAndData.second=0; globa_menu = 1; f_aktive_menu = 0; //curent_cmd = 0; PWatch_Setup_Step = 0; key_up = 0; key_down = 0; key_ok = 0; PCount_Start = 0; while(1) { key = 0; key_ok = GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0); key_down = GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_2); key_up = GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_12); /* OLED_DrawString_fast(0,0," ",10); IntToStr(bbb,key_ok); OLED_DrawString_fast(0,0,bbb,10); IntToStr(bbb,key_down); OLED_DrawString_fast(30,0,bbb,10); IntToStr(bbb,key_up); OLED_DrawString_fast(60,0,bbb,10); */ if (key_ok!=0) { key_ok = 0; key = 1; //OLED_DrawString_fast(0,0,"000000000",10); //f_aktive_menu = 1; /* if (f_aktive_menu == 1) { //f_work_comand = 1; f_aktive_menu = 0; f_clearScrin = 1; curent_cmd = menu_cmd[globa_menu-1]; } else curent_cmd = 255 ; */ } if (key_down==0) { key_down = 0; key = 2; /* if ((globa_menu>1)&&(f_work_comand == 0)) globa_menu--; else globa_menu = 1; //IntToStr(bbb,globa_menu); //OLED_DrawString_fast(0,0,bbb,10); */ } if (key_up==0) { key_up = 0; key = 12; /* if ((globa_menu<4)&&(f_work_comand == 0)) globa_menu++; else globa_menu = 4; //IntToStr(bbb,globa_menu); //OLED_DrawString_fast(0,0,bbb,10); */ } if (key!=0) { GPIO_SetBits(GPIOA, GPIO_Pin_1); delay_ms(30); GPIO_ResetBits(GPIOA, GPIO_Pin_1); } /* if (f_clearScrin==1) { OLED_Clear(); f_clearScrin=0; } */ //if (f_aktive_menu==0) //{ switch(curent_cmd) { case 0: //нет команды PWatch_Menu(); break; case 1: //Программа показа часов (главная страница) //OLED_Clear(); //f_work_comand = 1; PWatch_Anim(); break; case 2: //Программа настройки даты/времени и др. //OLED_Clear(); OLED_DrawString_fast(0,0,"Календарь",10); curent_cmd = 0; break; case 3: //OLED_Clear(); PWatch_Set_Alarm(); break; case 4: //OLED_Clear(); //OLED_DrawString_fast(0,0,"Настройки",10); //f_work_comand = 1; PWatch_Setup(); break; case 5: PWatch_Vibration(); break; case 254: OLED_Clear(); break; /*case 255: OLED_Clear(); OLED_DrawBitmap_fast(3,12,menu1_sprait,123,40); f_aktive_menu = 1; //f_work_comand = 0; //key=0; break; */ default: //выполнить, если ни один вариант не подошел break; } //} //else //{ //PWatch_Menu(); //} /* if(WainToAlarm == 1) { OLED_DrawString_fast(0,0,"alarm1",10); WainToAlarm =0; } */ //if(WaitToSleep>=5) //{ //WaitToSleep=0; //PWR_ClearFlag(PWR_FLAG_SB); //Сброс флага, который указывает на то, что МК вышел из режима standby /* for (i=255; i>0; i--) { OLED_SetContrast(i); IntToStr(a,i); OLED_DrawString_fast(0,0,a,10); //delay_ms(500); }*/ //OLED_DrawBitmap_fast(32,10,Fallout_Bitmaps,58,60); //delay_ms(1000); //OLED_Display_Off();!!!!!!!!!!!!!!!!!!!!!!!!1 //RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, DISABLE); //походу стабилитрон кушает 0.1 мА, общее потребление 0.15мА //PWR_EnterSTANDBYMode();!!!!!!!!!!!!!!!!!!!!! //} //WaitToSleep++; /* RCC_GetClocksFreq(&Frequency); f=Frequency.SYSCLK_Frequency/1000; IntToStr(a,f); OLED_DrawString_fast(0,0,a,10); */ delay_ms(250); } }
/** * @brief This function configures the system to enter Standby mode with RTC * clocked by LSE or LSI and with Backup SRAM ON for current consumption * measurement purpose. * STANDBY Mode with RTC clocked by LSE/LSI and BKPSRAM * ==================================================== * - RTC Clocked by LSE or LSI * - Backup SRAM ON * - IWDG OFF * - Automatic Wakeup using RTC clocked by LSE/LSI (after ~20s) * @param None * @retval None */ void StandbyRTCBKPSRAMMode_Measure(void) { /* Allow access to RTC */ PWR_BackupAccessCmd(ENABLE); #if defined (RTC_CLOCK_SOURCE_LSI) /* LSI used as RTC source clock*/ /* The RTC Clock may varies due to LSI frequency dispersion. */ /* Enable the LSI OSC */ RCC_LSICmd(ENABLE); /* Wait till LSI is ready */ while(RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET) { } /* Select the RTC Clock Source */ RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI); #elif defined (RTC_CLOCK_SOURCE_LSE) /* LSE used as RTC source clock */ /* Enable the LSE OSC */ RCC_LSEConfig(RCC_LSE_ON); /* Wait till LSE is ready */ while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) { } /* Select the RTC Clock Source */ RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE); #else #error Please select the RTC Clock source inside the main.c file #endif /* RTC_CLOCK_SOURCE_LSI */ /* Enable the RTC Clock */ RCC_RTCCLKCmd(ENABLE); /* Wait for RTC APB registers synchronisation */ RTC_WaitForSynchro(); /* Backup SRAM ***************************************************************/ /* Enable BKPRAM Clock */ RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_BKPSRAM, ENABLE); /* Enable the Backup SRAM low power Regulator */ PWR_BackupRegulatorCmd(ENABLE); /* Wait until the Backup SRAM low power Regulator is ready */ while(PWR_GetFlagStatus(PWR_FLAG_BRR) == RESET) { } /* RTC Wakeup Interrupt Generation: Clock Source: RTCCLK_Div16, Wakeup Time Base: ~20s RTC Clock Source LSE 32.768KHz or LSI ~32KHz Wakeup Time Base = (16 / (LSE or LSI)) * WakeUpCounter */ RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div16); RTC_SetWakeUpCounter(0xA000-1); /* Disable the Wakeup Interrupt */ RTC_ITConfig(RTC_IT_WUT, DISABLE); /* Clear Power WakeUp (CWUF) pending flag */ PWR_ClearFlag(PWR_FLAG_WU); /* Enable the Wakeup Interrupt */ RTC_ITConfig(RTC_IT_WUT, ENABLE); /* Enable Wakeup Counter */ RTC_WakeUpCmd(ENABLE); /* Clear WakeUp (WUTF) pending flag */ RTC_ClearFlag(RTC_FLAG_WUTF); /* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */ PWR_EnterSTANDBYMode(); /* Infinite loop */ while (1) { } }
/** * @brief Selects HSI as System clock source and configure HCLK, PCLK2 and PCLK1 prescalers. * @param None * @retval None */ void SetHCLKToHSI(void) { __IO uint32_t StartUpCounter = 0, HSIStatus = 0; /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration -----------------------------*/ /* RCC system reset(for debug purpose) */ RCC_DeInit(); /* Enable HSI */ RCC_HSICmd(ENABLE); /* Wait till HSI is ready and if Time out is reached exit */ do { HSIStatus = RCC_GetFlagStatus(RCC_FLAG_HSIRDY); StartUpCounter++; } while ((HSIStatus == 0) && (StartUpCounter != HSI_STARTUP_TIMEOUT)); if (RCC_GetFlagStatus(RCC_FLAG_HSIRDY) != RESET) { HSIStatus = (uint32_t)0x01; } else { HSIStatus = (uint32_t)0x00; } if (HSIStatus == 0x01) { /* Flash 0 wait state */ FLASH_SetLatency(FLASH_Latency_0); /* Disable Prefetch Buffer */ FLASH_PrefetchBufferCmd(DISABLE); /* Disable 64-bit access */ FLASH_ReadAccess64Cmd(DISABLE); /* Enable the PWR APB1 Clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); /* Select the Voltage Range 1 (1.8V) */ PWR_VoltageScalingConfig(PWR_VoltageScaling_Range1); /* Wait Until the Voltage Regulator is ready */ while (PWR_GetFlagStatus(PWR_FLAG_VOS) != RESET) {} /* HCLK = SYSCLK */ RCC_HCLKConfig(RCC_SYSCLK_Div1); /* PCLK2 = HCLK */ RCC_PCLK2Config(RCC_HCLK_Div1); /* PCLK1 = HCLK */ RCC_PCLK1Config(RCC_HCLK_Div1); /* Select HSI as system clock source */ RCC_SYSCLKConfig(RCC_SYSCLKSource_HSI); /* Wait till HSI is used as system clock source */ while (RCC_GetSYSCLKSource() != 0x04) {} } else { /* If HSI fails to start-up, the application will have wrong clock configuration. User can add here some code to deal with this error */ /* Go to infinite loop */ while (1) {} } }
int main(void) { bool StanbyWakeUp ; float Current_STBY; /*!< At this stage the microcontroller clock setting is already configured, this is done through SystemInit() function which is called from startup file (startup_stm32l1xx_md.s) before to branch to application main. To reconfigure the default setting of SystemInit() function, refer to system_stm32l1xx.c file */ Int_CurrentSTBY = Current_Measurement(); /* Check if the StandBy flag is set */ if (PWR_GetFlagStatus(PWR_FLAG_SB) != RESET) { /* System resumed from STANDBY mode */ /* Clear StandBy flag */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR,ENABLE); PWR_ClearFlag(PWR_FLAG_SB); StanbyWakeUp = TRUE; } else { StanbyWakeUp = FALSE; } PWR_PVDCmd(DISABLE); RCC_Configuration(); PWR_VoltageScalingConfig(PWR_VoltageScaling_Range1); /* Wait Until the Voltage Regulator is ready */ while (PWR_GetFlagStatus(PWR_FLAG_VOS) != RESET) ; /* Init I/O ports */ Init_GPIOs (); /* Initializes ADC */ ADC_Icc_Init(); enableInterrupts(); /* Warning ! in TSL Init the sysTick interrupt is setted to: SysTick_Config(RCC_Clocks.HCLK_Frequency / 2000 ---> 500 µs*/ /* Init Touch Sensing configuration */ TSL_Init(); sMCKeyInfo[0].Setting.b.IMPLEMENTED = 1; sMCKeyInfo[0].Setting.b.ENABLED = 1; sMCKeyInfo[0].DxSGroup = 0x00; /* Initializes the LCD glass */ LCD_GLASS_Init(); while (1) { switch( State ) { case 0: //LED3 off and LED4 off blink = 0; GPIOB_ODR_value = 0x00000000; ptr_PORTB->GPIOx_ODR = GPIOB_ODR_value; break; case 1: //LED3 on and LED4 off blink = 0; GPIOB_ODR_value = 0x00000080; ptr_PORTB->GPIOx_ODR = GPIOB_ODR_value; break; case 2: //LED3 off and LED4 on blink = 0; GPIOB_ODR_value = 0x00000040; ptr_PORTB->GPIOx_ODR = GPIOB_ODR_value; break; case 3: //LED3 and LED4 blink with 2 second period blink = 1; break; } if(blink == 1) { GPIOB_ODR_value = 0x000000C0; ptr_PORTB->GPIOx_ODR = GPIOB_ODR_value; Delay(100); GPIOB_ODR_value = 0x00000000; ptr_PORTB->GPIOx_ODR = GPIOB_ODR_value; Delay(100); } } return(0); }
/** * @brief Configures the RTC. * @param None * @retval None */ static void RTC_Config(void) { RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); /* Allow access to BKP Domain */ PWR_BackupAccessCmd(ENABLE); /* Clear Wakeup flag */ PWR_ClearFlag(PWR_FLAG_WU); /* Check if the StandBy flag is set */ if (PWR_GetFlagStatus(PWR_FLAG_SB) != RESET) { /* Clear StandBy flag */ PWR_ClearFlag(PWR_FLAG_SB); /* Wait for RTC APB registers synchronisation (needed after start-up from Reset)*/ RTC_WaitForSynchro(); /* No need to configure the RTC as the RTC config(clock source, enable, prescaler,...) are kept after wake-up from STANDBY */ } else { /* RTC Configuration ******************************************************/ /* Reset Backup Domain */ RCC_BackupResetCmd(ENABLE); RCC_BackupResetCmd(DISABLE); #if defined (RTC_CLOCK_SOURCE_LSI) /* LSI used as RTC source clock*/ /* The RTC Clock may varies due to LSI frequency dispersion. */ /* Enable the LSI OSC */ RCC_LSICmd(ENABLE); /* Wait till LSI is ready */ while(RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET) { } /* Select the RTC Clock Source */ RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI); SynchPrediv = 0xFF; AsynchPrediv = 0x7F; #elif defined (RTC_CLOCK_SOURCE_LSE) /* LSE used as RTC source clock */ /* Enable the LSE OSC */ RCC_LSEConfig(RCC_LSE_ON); /* Wait till LSE is ready */ while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) { } /* Select the RTC Clock Source */ RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE); SynchPrediv = 0xFF; AsynchPrediv = 0x7F; #else #error Please select the RTC Clock source inside the main.c file #endif /* RTC_CLOCK_SOURCE_LSI */ /* Enable the RTC Clock */ RCC_RTCCLKCmd(ENABLE); /* Wait for RTC APB registers synchronisation (needed after start-up from Reset)*/ RTC_WaitForSynchro(); /* Set the RTC time base to 1s */ RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24; RTC_InitStructure.RTC_AsynchPrediv = 0x7F; RTC_InitStructure.RTC_SynchPrediv = 0x00FF; if (RTC_Init(&RTC_InitStructure) == ERROR) { /* Turn on LED2 */ STM_EVAL_LEDOn(LED2); /* User can add here some code to deal with this error */ while(1); } /* Set the time to 01h 00mn 00s AM */ RTC_TimeStructure.RTC_H12 = RTC_H12_AM; RTC_TimeStructure.RTC_Hours = 0x01; RTC_TimeStructure.RTC_Minutes = 0x00; RTC_TimeStructure.RTC_Seconds = 0x00; if(RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure) == ERROR) { /* Turn on LED2 */ STM_EVAL_LEDOn(LED2); /* User can add here some code to deal with this error */ while(1); } } /* Clear RTC Alarm Flag */ RTC_ClearFlag(RTC_FLAG_ALRAF); }
/** * @brief Configures the RTC clock source. * @param None * @retval None */ void RTC_Config(void) { RTC_InitTypeDef RTC_InitStructure; RTC_AlarmTypeDef RTC_AlarmStructure; RTC_TimeTypeDef RTC_TimeStructure; /* Enable the PWR clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); /* Allow access to Backup Domain */ PWR_BackupAccessCmd(ENABLE); /* Check if the StandBy flag is set */ if (PWR_GetFlagStatus(PWR_FLAG_SB) != RESET) { /* Clear StandBy flag */ PWR_ClearFlag(PWR_FLAG_SB); /* Check if the StandBy flag is cleared */ if (PWR_GetFlagStatus(PWR_FLAG_SB) != RESET) { while(1); } RTC_WaitForSynchro(); /* No need to configure the RTC as the RTC config(clock source, enable, prescaler,...) are kept after wake-up from STANDBY */ } else { /* RTC Configuration ******************************************************/ /* Reset Backup Domain */ RCC_BackupResetCmd(ENABLE); RCC_BackupResetCmd(DISABLE); /* Enable the LSI OSC */ RCC_LSICmd(ENABLE); /* Wait till LSI is ready */ while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET) {} /* Select the RTC Clock Source */ RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI); /* Enable the RTC Clock */ RCC_RTCCLKCmd(ENABLE); /* Wait for RTC APB registers synchronisation */ RTC_WaitForSynchro(); RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24; RTC_InitStructure.RTC_AsynchPrediv = 0x7F; RTC_InitStructure.RTC_SynchPrediv = 0x0138; RTC_Init(&RTC_InitStructure); /* Set the alarm X+5s */ RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_H12_AM; RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = 0x01; RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = 0x00; RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = 0x3; RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31; RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date; RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay; RTC_SetAlarm(RTC_Format_BCD, RTC_Alarm_A, &RTC_AlarmStructure); /* Enable RTC Alarm A Interrupt */ RTC_ITConfig(RTC_IT_ALRA, ENABLE); /* Enable the alarm */ RTC_AlarmCmd(RTC_Alarm_A, ENABLE); } /* Set the time to 01h 00mn 00s AM */ RTC_TimeStructure.RTC_H12 = RTC_H12_AM; RTC_TimeStructure.RTC_Hours = 0x01; RTC_TimeStructure.RTC_Minutes = 0x00; RTC_TimeStructure.RTC_Seconds = 0x00; RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure); /* Clear Wakeup flag */ PWR_ClearFlag(PWR_FLAG_WU); RTC_ClearFlag(RTC_FLAG_ALRAF); /* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */ PWR_EnterSTANDBYMode(); }
/** * @brief Configure the RTC peripheral by selecting the clock source. * @param None * @retval None */ void RTC_Config(void) { /* Enable the PWR clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); /* Allow access to RTC */ PWR_BackupAccessCmd(ENABLE); #if defined (RTC_CLOCK_SOURCE_LSI) /* LSI used as RTC source clock*/ /* The RTC Clock may varies due to LSI frequency dispersion. */ /* Enable the LSI OSC */ RCC_LSICmd(ENABLE); /* Wait till LSI is ready */ while(RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET) { } /* Select the RTC Clock Source */ RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI); SynchPrediv = 0xFF; AsynchPrediv = 0x7F; #elif defined (RTC_CLOCK_SOURCE_LSE) /* LSE used as RTC source clock */ /* Enable the LSE OSC */ RCC_LSEConfig(RCC_LSE_ON); /* Wait till LSE is ready */ while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) { } /* Select the RTC Clock Source */ RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE); SynchPrediv = 0xFF; AsynchPrediv = 0x7F; #else #error Please select the RTC Clock source inside the main.c file #endif /* RTC_CLOCK_SOURCE_LSI */ /* Enable the RTC Clock */ RCC_RTCCLKCmd(ENABLE); /* Wait for RTC APB registers synchronisation */ RTC_WaitForSynchro(); /* Write to the first RTC Backup Data Register */ RTC_WriteBackupRegister(RTC_BKP_DR0, FIRST_DATA); /* Display the new RCC BDCR and RTC TAFCR Registers */ LCD_UsrLog ("RTC Reconfig \n"); LCD_UsrLog ("RCC BDCR = 0x%x\n", RCC->BDCR); LCD_UsrLog ("RTC TAFCR = 0x%x\n", RTC->TAFCR); /* Set the Time */ RTC_TimeStructure.RTC_Hours = 0x08; RTC_TimeStructure.RTC_Minutes = 0x00; RTC_TimeStructure.RTC_Seconds = 0x00; /* Set the Date */ RTC_DateStructure.RTC_Month = RTC_Month_March; RTC_DateStructure.RTC_Date = 0x18; RTC_DateStructure.RTC_Year = 0x11; RTC_DateStructure.RTC_WeekDay = RTC_Weekday_Friday; /* Calendar Configuration */ RTC_InitStructure.RTC_AsynchPrediv = AsynchPrediv; RTC_InitStructure.RTC_SynchPrediv = SynchPrediv; RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24; RTC_Init(&RTC_InitStructure); /* Set Current Time and Date */ RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure); RTC_SetDate(RTC_Format_BCD, &RTC_DateStructure); /* Configure the RTC Wakeup Clock source and Counter (Wakeup event each 1 second) */ RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div16); RTC_SetWakeUpCounter(0x7FF); /* Enable the Wakeup Interrupt */ RTC_ITConfig(RTC_IT_WUT, ENABLE); /* Enable Wakeup Counter */ RTC_WakeUpCmd(ENABLE); /* Backup SRAM ***************************************************************/ /* Enable BKPRAM Clock */ RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_BKPSRAM, ENABLE); /* Write to Backup SRAM with 32-Bit Data */ for (i = 0x0; i < 0x1000; i += 4) { *(__IO uint32_t *) (BKPSRAM_BASE + i) = i; } /* Check the written Data */ for (i = 0x0; i < 0x1000; i += 4) { if ((*(__IO uint32_t *) (BKPSRAM_BASE + i)) != i) { errorindex++; } } if(errorindex) { LCD_ErrLog ("BKP SRAM Number of errors = %d\n", errorindex); } else { LCD_UsrLog ("BKP SRAM write OK \n"); } /* Enable the Backup SRAM low power Regulator to retain it's content in VBAT mode */ PWR_BackupRegulatorCmd(ENABLE); /* Wait until the Backup SRAM low power Regulator is ready */ while(PWR_GetFlagStatus(PWR_FLAG_BRR) == RESET) { } /* RTC Backup Data Registers **************************************************/ /* Write to RTC Backup Data Registers */ WriteToBackupReg(FIRST_DATA); }
/** * @brief Configures the RTC clock source. * @param None * @retval None */ static void RTC_Config(void) { RTC_InitTypeDef RTC_InitStructure; RTC_TimeTypeDef RTC_TimeStructure; uint32_t LSIFreq = 0; /* Enable the PWR clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); /* Allow access to Backup Domain */ PWR_BackupAccessCmd(ENABLE); /* Clear Wakeup flag */ PWR_ClearFlag(PWR_FLAG_WU); /* Enable the LSI OSC */ RCC_LSICmd(ENABLE); /* Wait till LSI is ready */ while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET) {} /* Check if the StandBy flag is set */ if (PWR_GetFlagStatus(PWR_FLAG_SB) != RESET) { /* Clear StandBy flag */ PWR_ClearFlag(PWR_FLAG_SB); /* Check if the StandBy flag is cleared */ if (PWR_GetFlagStatus(PWR_FLAG_SB) != RESET) { while(1); } RTC_WaitForSynchro(); /* No need to configure the RTC as the RTC config(clock source, enable, prescaler,...) are kept after wake-up from STANDBY */ } else { /* RTC Configuration ******************************************************/ /* Reset Backup Domain */ RCC_BackupResetCmd(ENABLE); RCC_BackupResetCmd(DISABLE); /* Select the RTC Clock Source */ RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI); /* Enable the RTC Clock */ RCC_RTCCLKCmd(ENABLE); /* Wait for RTC APB registers synchronisation */ RTC_WaitForSynchro(); /* Get the LSI frequency: TIM14 is used to measure the LSI frequency */ LSIFreq = GetLSIFrequency(); RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24; RTC_InitStructure.RTC_AsynchPrediv = 99; RTC_InitStructure.RTC_SynchPrediv = (LSIFreq/100) - 1; RTC_Init(&RTC_InitStructure); /* Set the time to 01h 00mn 00s AM */ RTC_TimeStructure.RTC_H12 = RTC_H12_AM; RTC_TimeStructure.RTC_Hours = 0x01; RTC_TimeStructure.RTC_Minutes = 0x00; RTC_TimeStructure.RTC_Seconds = 0x00; RTC_SetTime(RTC_Format_BIN, &RTC_TimeStructure); } }