/**
* @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 (PI.11)
* @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: 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);
/* Request to enter STANDBY mode */
HAL_PWR_EnterSTANDBYMode();
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 100 MHz */
SystemClock_Config();
/* Configure LED2 */
BSP_LED_Init(LED2);
/* Enable Power Clock */
__HAL_RCC_PWR_CLK_ENABLE();
/* Check and handle if the system was resumed from Standby mode */
if(__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET)
{
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);
/* Infinite loop */
while (1)
{
/* Toggle LED2 */
BSP_LED_Toggle(LED2);
/* Insert a 100ms delay */
HAL_Delay(100);
}
}
/* Configure USER Button */
BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);
/* Wait until USER button is pressed to enter the Low Power mode */
while(BSP_PB_GetState(BUTTON_KEY) != RESET)
{
/* Toggle LED2 */
BSP_LED_Toggle(LED2);
/* Insert 1s Delay */
HAL_Delay(1000);
}
/* Loop while USER Button is maintained pressed */
while(BSP_PB_GetState(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.
- Wake-up using EXTI Line (User Button)
*/
SleepMode_Measure();
#elif defined (STOP_MODE)
/* STOP Mode Entry
- RTC Clocked by 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 Wake-up using RTC clocked by LSI (after ~20s)
*/
StopMode_Measure();
#elif defined (STANDBY_MODE)
/* STANDBY Mode Entry
- Backup SRAM and RTC OFF
- IWDG and LSI OFF
- Wake-up using WakeUp Pin (PA.00)
*/
StandbyMode_Measure();
#elif defined (STANDBY_RTC_MODE)
/* STANDBY Mode with RTC on LSI Entry
- RTC Clocked by LSI
- IWDG OFF and LSI OFF if not used as RTC Clock source
- Backup SRAM OFF
- Automatic Wake-up using RTC clocked by LSI (after ~20s)
*/
StandbyRTCMode_Measure();
#elif defined (STANDBY_RTC_BKPSRAM_MODE)
/* STANDBY Mode with RTC on LSI Entry
- RTC Clocked by LSI
- Backup SRAM ON
- IWDG OFF
- Automatic Wake-up using RTC clocked by LSI (after ~20s)
*/
StandbyRTCBKPSRAMMode_Measure();
#endif
if(uwCounter != 0)
{
BSP_LED_Init(LED2);
}
/* Infinite loop */
while (1)
{
/* Toggle LED2 */
BSP_LED_Toggle(LED2);
/* Inserted Delay */
HAL_Delay(100);
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F0xx HAL library initialization:
- Configure the Flash prefetch
- Configure the Systick to generate an interrupt each 1 msec
- Low Level Initialization
*/
HAL_Init();
/* Configure LED */
BSP_LED_Init(LED2);
/* Configure the system clock to 48 MHz */
SystemClock_Config();
/* Enable Power Clock */
__PWR_CLK_ENABLE();
/* Check and handle if the system was resumed from StandBy mode */
if (__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET)
{
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);
/* Turn on the LED2 and keep
it on for 2 sec. to indicate
exit from stand-by mode */
BSP_LED_On(LED2);
HAL_Delay(2000);
}
/* Infinite loop */
while(1)
{
/* Configure User push-button */
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI);
UserButtonStatus = 0;
/* Wait until User push-button is pressed to enter the Low Power mode.
In the meantime, LED2 is blinking */
while (UserButtonStatus == 0)
{
/* Toggle LED2 */
BSP_LED_Toggle(LED2);
HAL_Delay(100);
}
/* Loop while User push-button is maintained pressed */
while(BSP_PB_GetState(BUTTON_USER) != SET){}
/* Make sure LED2 is turned off to
reduce low power mode consumption */
BSP_LED_Off(LED2);
#if defined (SLEEP_MODE)
/* Sleep Mode Entry
- System Running at PLL (48 MHz)
- Flash 1 wait state
- Instruction and Data caches ON
- Prefetch ON
- Code running from Internal FLASH
- All peripherals disabled.
- Wakeup using EXTI Line (User push-button PC.13)
*/
SleepMode_Measure();
#elif defined (STOP_MODE)
/* STOP Mode Entry
- RTC Clocked by LSI
- Regulator in LP mode
- HSI, HSE OFF and LSI OFF if not used as RTC Clock source
- No IWDG
- Wakeup using EXTI Line (User push-button PC.13)
*/
StopMode_Measure();
#elif defined (STOP_RTC_MODE)
/* STOP Mode Entry
- RTC Clocked by LSI
- Regulator in LP mode
- HSI, HSE OFF and LSI OFF if not used as RTC Clock source
- No IWDG
- Automatic Wakeup using RTC clocked by LSI (after ~20s)
*/
StopRTCMode_Measure();
#elif defined (STANDBY_MODE)
/* STANDBY Mode Entry
- RTC OFF
- IWDG and LSI OFF
- Wakeup using WakeUp Pin (wire Vdd to PA.00)
*/
StandbyMode_Measure();
#elif defined (STANDBY_RTC_MODE)
/* STANDBY Mode with RTC on LSI Entry
- RTC Clocked by LSI
- IWDG OFF and LSI OFF if not used as RTC Clock source
- Automatic Wakeup using RTC clocked by LSI (after ~20s)
*/
StandbyRTCMode_Measure();
#endif /* SLEEP_MODE */
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F0xx HAL library initialization:
- Configure the Flash prefetch
- 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.
- Low Level Initialization
*/
HAL_Init();
/* Configure LED */
BSP_LED_Init(LED2);
/* Configure the system clock to 48 MHz */
SystemClock_Config();
/* Enable Power Clock */
__HAL_RCC_PWR_CLK_ENABLE();
/* Check and handle if the system was resumed from StandBy mode */
if (__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET)
{
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);
/* Configure User push-button */
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_GPIO);
/* Turn on the LED2 and keep
it on for 2 sec. to indicate
exit from stand-by mode */
BSP_LED_On(LED2);
while(BSP_PB_GetState(BUTTON_USER) == GPIO_PIN_RESET){}
HAL_Delay(2000);
uwStandByOutFlag = 1;
}
/* Infinite loop */
while(1)
{
/* Configure User push-button as external interrupt generator */
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI);
UserButtonStatus = 0;
/* Wait until User push-button is pressed to enter the Low Power mode.
In the meantime, LED2 is blinks */
while (UserButtonStatus == 0)
{
/* Toggle LED2 */
BSP_LED_Toggle(LED2);
HAL_Delay(100);
}
/* Make sure LED2 is turned off to
reduce low power mode consumption */
BSP_LED_Off(LED2);
#if defined (SLEEP_MODE)
/* Sleep Mode Entry
- System Running at PLL (48 MHz)
- Flash 2 wait state
- Instruction and Data caches ON
- Prefetch ON
- Code running from Internal FLASH
- All peripherals disabled.
- Wakeup using EXTI Line (User push-button PC.13)
*/
SleepMode_Measure();
#elif defined (STOP_RTC_MODE)
/* STOP Mode Entry
- RTC Clocked by LSI or LSE
- Regulator in LP mode
- HSI, HSE OFF and LSI OFF if not used as RTC Clock source
- No IWDG
- Automatic Wakeup using RTC clocked by LSI (after ~20s)
- Wakeup using EXTI Line (User push-button PC.13)
*/
StopRTCMode_Measure();
#elif defined (STANDBY_MODE)
/* STANDBY Mode Entry
- RTC OFF
- IWDG and LSI OFF
- Wakeup using WakeUp Pin PWR_WAKEUP_PIN2 connected to PC.13
*/
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
- Automatic Wakeup using RTC clocked by LSE/LSI (after ~20s)
*/
StandbyRTCMode_Measure();
#endif
}
}
/**
* @brief EXTI line detection callbacks
* @param GPIO_Pin: Specifies the pins connected EXTI line
* @retval None
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
if(GPIO_Pin == TAMPER_BUTTON_PIN)
{
HAL_RTC_GetTime(&RTCHandle, &RTC_TimeStructure, RTC_FORMAT_BIN);
HAL_RTC_GetDate(&RTCHandle, &RTC_DateStructure, RTC_FORMAT_BIN);
/* Set the alarm to current time + 5s */
RTC_AlarmStructure.Alarm = RTC_ALARM_A;
RTC_AlarmStructure.AlarmTime.TimeFormat = RTC_TimeStructure.TimeFormat;
RTC_AlarmStructure.AlarmTime.Hours = RTC_TimeStructure.Hours;
RTC_AlarmStructure.AlarmTime.Minutes = RTC_TimeStructure.Minutes;
RTC_AlarmStructure.AlarmTime.Seconds = (RTC_TimeStructure.Seconds + 0x05) % 60;
RTC_AlarmStructure.AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.AlarmDateWeekDaySel = RTC_ALARMDATEWEEKDAYSEL_DATE;
RTC_AlarmStructure.AlarmMask = RTC_ALARMMASK_DATEWEEKDAY | RTC_ALARMMASK_HOURS | RTC_ALARMMASK_MINUTES;
RTC_AlarmStructure.AlarmSubSecondMask = RTC_ALARMSUBSECONDMASK_NONE;
/* 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 #####################################*/
/* Disable Wake-up timer */
HAL_PWR_DisableWakeUpPin(PWR_WAKEUP_PIN1);
/* Disable RTC Alarm */
HAL_RTC_DeactivateAlarm(&RTCHandle, RTC_ALARM_A);
/*## Clear all related wakeup flags ######################################*/
/* Clear PWR wake up Flag */
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
/* Clear the Alarm Flag */
__HAL_RTC_ALARM_CLEAR_FLAG(&RTCHandle, RTC_FLAG_ALRAF);
/*## Re-enable all used wakeup sources ###################################*/
/* Set RTC alarm */
if(HAL_RTC_SetAlarm_IT(&RTCHandle, &RTC_AlarmStructure, RTC_FORMAT_BIN) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* Enable WKUP pin */
HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);
/* Turn LED1 off */
BSP_LED_Off(LED1);
/*## Enter Standby Mode ##################################################*/
HAL_PWR_EnterSTANDBYMode();
}
if(GPIO_Pin == MFX_IRQOUT_PIN)
{
/* The different functionalities of MFX (TS, Joystick, SD detection, etc. )
can be configured in exti mode to generate an IRQ on given events.
The MFX IRQ_OUT pin is unique and common to all functionalities, so if several
functionalities are configured in exit mode, the MCU has to enquire MFX about
the IRQ source (see BSP_IO_ITGetStatus). Communication with Mfx is done by I2C.
Often the sw requires ISRs (irq service routines) to be quick while communication
with I2C can be considered relatively long (hundreds of usec depending on I2C clk).
Considering that the features for human interaction like TS, Joystick, SD detection
don’t need immediate reaction, it is suggested to use POLLING instead of EXTI mode,
in order to avoid "blocking I2C communication" on interrupt service routines */
/* Here an example of implementation is proposed: mix between pooling and exit:
On ISR a flag is set (MfxIrqReceived), the main loop polls on the flag;
Mcu communicates with Mfx only when the flag has been set. This is just an example:
the users should choose they strategy depending on their application needs.*/
MfxExtiReceived = 1;
}
}
/**
* @brief This function configures the RTC_WKUP as a time base source.
* The time source is configured to have 1ms time base with a dedicated
* Tick interrupt priority.
* Wakeup Time base = ((RTC_ASYNCH_PREDIV + 1) * (RTC_SYNCH_PREDIV + 1)) / RTC_CLOCK
= 1ms
* Wakeup Time = WakeupTimebase * WakeUpCounter (0 + 1)
= 1 ms
* @note This function is called automatically at the beginning of program after
* reset by HAL_Init() or at any time when clock is configured, by HAL_RCC_ClockConfig().
* @param TickPriority: Tick interrupt priority.
* @retval HAL status
*/
HAL_StatusTypeDef HAL_InitTick (uint32_t TickPriority)
{
__IO uint32_t counter = 0U;
RCC_OscInitTypeDef RCC_OscInitStruct;
RCC_PeriphCLKInitTypeDef PeriphClkInitStruct;
#ifdef RTC_CLOCK_SOURCE_LSE
/* 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;
PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
#elif defined (RTC_CLOCK_SOURCE_LSI)
/* Configue LSI as RTC clock soucre */
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
RCC_OscInitStruct.LSIState = RCC_LSI_ON;
PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;
#elif defined (RTC_CLOCK_SOURCE_HSE)
/* Configue HSE as RTC clock soucre */
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
/* Ensure that RTC is clocked by 1MHz */
PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_1MHZ;
#else
#error Please select the RTC Clock source
#endif /* RTC_CLOCK_SOURCE_LSE */
if(HAL_RCC_OscConfig(&RCC_OscInitStruct) == HAL_OK)
{
PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;
if(HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) == HAL_OK)
{
/* Enable RTC Clock */
__HAL_RCC_RTC_ENABLE();
/* The time base should be 1ms
Time base = ((RTC_ASYNCH_PREDIV + 1) * (RTC_SYNCH_PREDIV + 1)) / RTC_CLOCK
HSE as RTC clock
Time base = ((99 + 1) * (9 + 1)) / 1Mhz
= 1ms
LSE as RTC clock
Time base = ((31 + 1) * (0 + 1)) / 32.768Khz
= ~1ms
LSI as RTC clock
Time base = ((31 + 1) * (0 + 1)) / 32Khz
= 1ms
*/
hRTC_Handle.Instance = RTC;
hRTC_Handle.Init.HourFormat = RTC_HOURFORMAT_24;
hRTC_Handle.Init.AsynchPrediv = RTC_ASYNCH_PREDIV;
hRTC_Handle.Init.SynchPrediv = RTC_SYNCH_PREDIV;
hRTC_Handle.Init.OutPut = RTC_OUTPUT_DISABLE;
hRTC_Handle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
hRTC_Handle.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
HAL_RTC_Init(&hRTC_Handle);
/* Disable the write protection for RTC registers */
__HAL_RTC_WRITEPROTECTION_DISABLE(&hRTC_Handle);
/* Disable the Wake-up Timer */
__HAL_RTC_WAKEUPTIMER_DISABLE(&hRTC_Handle);
/* In case of interrupt mode is used, the interrupt source must disabled */
__HAL_RTC_WAKEUPTIMER_DISABLE_IT(&hRTC_Handle,RTC_IT_WUT);
/* Wait till RTC WUTWF flag is set */
while(__HAL_RTC_WAKEUPTIMER_GET_FLAG(&hRTC_Handle, RTC_FLAG_WUTWF) == RESET)
{
if(counter++ == (SystemCoreClock /48U))
{
return HAL_ERROR;
}
}
/* Clear PWR wake up Flag */
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
/* Clear RTC Wake Up timer Flag */
__HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(&hRTC_Handle, RTC_FLAG_WUTF);
/* Configure the Wake-up Timer counter */
hRTC_Handle.Instance->WUTR = (uint32_t)0U;
/* Clear the Wake-up Timer clock source bits in CR register */
hRTC_Handle.Instance->CR &= (uint32_t)~RTC_CR_WUCKSEL;
/* Configure the clock source */
hRTC_Handle.Instance->CR |= (uint32_t)RTC_WAKEUPCLOCK_CK_SPRE_16BITS;
/* RTC WakeUpTimer Interrupt Configuration: EXTI configuration */
__HAL_RTC_WAKEUPTIMER_EXTI_ENABLE_IT();
__HAL_RTC_WAKEUPTIMER_EXTI_ENABLE_RISING_EDGE();
/* Configure the Interrupt in the RTC_CR register */
__HAL_RTC_WAKEUPTIMER_ENABLE_IT(&hRTC_Handle,RTC_IT_WUT);
/* Enable the Wake-up Timer */
__HAL_RTC_WAKEUPTIMER_ENABLE(&hRTC_Handle);
/* Enable the write protection for RTC registers */
__HAL_RTC_WRITEPROTECTION_ENABLE(&hRTC_Handle);
HAL_NVIC_SetPriority(RTC_WKUP_IRQn, TickPriority, 0U);
HAL_NVIC_EnableIRQ(RTC_WKUP_IRQn);
return HAL_OK;
}
}
return HAL_ERROR;
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32L0xx HAL library initialization:
- Configure the Flash prefetch, Flash preread and Buffer caches
- 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.
- Low Level Initialization
*/
HAL_Init();
/* Configure LED3 */
BSP_LED_Init(LED3);
/* Configure the system clock to 2 MHz */
SystemClock_Config();
/* System Power Configuration */
SystemPower_Config() ;
/* 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);
/* Blink LED3 to indicate that the system was resumed from Standby mode */
BSP_LED_On(LED3);
HAL_Delay(200);
BSP_LED_Off(LED3);
HAL_Delay(200);
}
/* Turn on LED3 */
BSP_LED_On(LED3);
/* Insert 5 seconds delay */
HAL_Delay(5000);
/* 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: PWR_WAKEUP_PIN3 */
HAL_PWR_DisableWakeUpPin(PWR_WAKEUP_PIN3);
/* Clear all related wakeup flags*/
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
/* Enable WakeUp Pin PWR_WAKEUP_PIN3 connected to PA.02 (Arduino A7) */
HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN3);
/* Enter the Standby mode */
HAL_PWR_EnterSTANDBYMode();
/* This code will never be reached! */
while (1)
{
}
}
/**
* @brief Configures the RTC.
* @param None
* @retval None
*/
static void RTC_Config(void)
{
RTCHandle.Instance = RTC;
/* Set the RTC time base to 1s */
/* Configure RTC prescaler and RTC data registers 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;
if(HAL_RTC_Init(&RTCHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* Check and Clear the Wakeup flag */
if(__HAL_PWR_GET_FLAG(PWR_FLAG_WU) != RESET)
{
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
}
/* 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)
{
/* Initialization Error */
Error_Handler();
}
/* 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
{
/* Set the time to 01h 00mn 00s AM */
RTC_TimeStructure.TimeFormat = RTC_HOURFORMAT12_AM;
RTC_TimeStructure.Hours = 0x01;
RTC_TimeStructure.Minutes = 0x00;
RTC_TimeStructure.Seconds = 0x00;
if(HAL_RTC_SetTime(&RTCHandle, &RTC_TimeStructure, RTC_FORMAT_BCD) == HAL_ERROR)
{
/* Initialization Error */
Error_Handler();
}
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F3xx HAL library initialization:
- Configure the Flash prefetch
- 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 Green, Red and Orange LEDs */
BSP_LED_Init(LED_GREEN);
BSP_LED_Init(LED_RED);
BSP_LED_Init(LED_ORANGE);
/* Configure the system clock to 72 Mhz */
SystemClock_Config();
/* Enable Power Clock */
__PWR_CLK_ENABLE();
/* Check and handle if the system was resumed from StandBy mode */
if(__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET)
{
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);
/* Turn on the Orange LED */
BSP_LED_On(LED_ORANGE);
uwStandByOutFlag = 1;
}
/* infinite loop */
while(1)
{
/* Configure User Button */
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI);
UserButtonStatus = 0;
/* Wait until User button is pressed to enter the Low Power mode.
In the meantime, LED_GREEN is blinking */
while(UserButtonStatus == 0)
{
BSP_LED_Toggle(LED_GREEN);
HAL_Delay(100);
/* if exiting from stand-by mode,
keep LED_ORANGE ON for about 3 sec. */
if (uwStandByOutFlag > 0)
{
uwStandByOutFlag++;
if (uwStandByOutFlag == 30)
{
BSP_LED_Off(LED_ORANGE);
uwStandByOutFlag = 0;
}
}
/* if exiting from stop mode thru RTC alarm
interrupt, keep LED_ORANGE ON for about 3 sec. */
if (uwWakeUpIntFlag > 0)
{
uwWakeUpIntFlag++;
if (uwWakeUpIntFlag == 30)
{
BSP_LED_Off(LED_BLUE);
uwWakeUpIntFlag = 0;
}
}
}
/* Loop while Key button is maintained pressed */
while(BSP_PB_GetState(BUTTON_USER) != SET) {}
/* Make sure LED_GREEN is turned off to
reduce low power mode consumption */
BSP_LED_Off(LED_GREEN);
#if defined (SLEEP_MODE)
/* Sleep Mode Entry
- System Running at PLL (72 MHz)
- Flash 2 wait state
- Instruction and Data caches ON
- Prefetch ON
- Code running from Internal FLASH
- All peripherals disabled.
- Wakeup using EXTI Line (User Button PA.00)
*/
SleepMode_Measure();
#elif defined (STOP_MODE)
/* STOP Mode Entry
- RTC Clocked by LSI
- Regulator in LP mode
- HSI, HSE OFF and LSI OFF if not used as RTC Clock source
- No IWDG
- Wakeup using EXTI Line (User Button PA.00)
*/
StopMode_Measure();
#elif defined (STOP_RTC_MODE)
/* STOP Mode Entry
- RTC Clocked by LSI
- Regulator in LP mode
- HSI, HSE OFF and LSI OFF if not used as RTC Clock source
- No IWDG
- Automatic Wakeup using RTC clocked by LSI (after ~20s)
*/
StopRTCMode_Measure();
#elif defined (STANDBY_MODE)
/* STANDBY Mode Entry
- Backup SRAM and RTC OFF
- IWDG and LSI OFF
- Wakeup using WakeUp Pin (User Button PA.00)
*/
StandbyMode_Measure();
#elif defined (STANDBY_RTC_MODE)
/* STANDBY Mode with RTC on LSI Entry
- RTC Clocked by LSI
- IWDG OFF and LSI OFF if not used as RTC Clock source
- Automatic Wakeup using RTC clocked by LSI (after ~20s)
*/
StandbyRTCMode_Measure();
#endif
}
}
/**
* @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)
{
/* Configure RTC prescaler and RTC data registers 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.Instance = RTC;
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();
}
/*## 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 20s the WakeUpCounter is set to 0xA017:
RTC_WAKEUPCLOCK_RTCCLK_DIV = RTCCLK_Div16 = 16
Wakeup Time Base = 16 /(~32.768KHz) = ~0,488 ms
Wakeup Time = ~20s = 0,488ms * WakeUpCounter
==> WakeUpCounter = ~20s/0,488ms = 40983 = 0xA017 */
/* Disable Wake-up timer */
if(HAL_RTCEx_DeactivateWakeUpTimer(&RTCHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*## Clear all related wakeup flags ########################################*/
/* Clear PWR wake up Flag */
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
/* Clear RTC Wake Up timer Flag */
__HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(&RTCHandle, RTC_FLAG_WUTF);
/*## Setting the Wake up time ##############################################*/
HAL_RTCEx_SetWakeUpTimer_IT(&RTCHandle, 0xA017, RTC_WAKEUPCLOCK_RTCCLK_DIV16);
/* Enable BKPRAM Clock */
__HAL_RCC_BKPSRAM_CLK_ENABLE();
/* Enable the Backup SRAM low power Regulator */
HAL_PWREx_EnableBkUpReg();
/*## Enter the Standby mode ################################################*/
/* Request to enter STANDBY mode */
HAL_PWR_EnterSTANDBYMode();
}
/**
* @brief GPIO EXTI callback
* @param None
* @retval None
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
/* Clear Wake Up Flag */
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F3xx HAL library initialization:
- Configure the Flash prefetch
- 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 LED3, LED4 */
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
/* Configure the system clock to 72 MHz */
SystemClock_Config();
/* Enable Power Clock */
__HAL_RCC_PWR_CLK_ENABLE();
/* Check if the system was resumed from StandBy mode */
if (__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET)
{
/* Wait that user release the User push-button */
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_GPIO);
while(BSP_PB_GetState(BUTTON_USER) == SET){}
}
/* Initialize the User push-button to generate external interrupts */
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI);
/* RTC configuration */
RTC_Config();
/* Turn on LED3 */
BSP_LED_On(LED3);
/*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: 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);
while (1)
{
}
}
void HAL_RTCEx_WakeUpTimerEventCallback(RTC_HandleTypeDef *hrtc)
{
/* Clear Wake Up Flag */
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
}
int main(void)
{
/* USER CODE BEGIN 1 */
trace_printf("Hello\n");
/* USER CODE END 1 */
/* MCU Configuration----------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize all configured peripherals */
MX_GPIO_Init();
/* USER CODE BEGIN 2 */
BSP_LED_Init(LED6);
BSP_LED_Init(LED5);
/* Checks if reset was because of wakeup from standby */
if (__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET)
{
/* Clear Standby and wakeup flag */
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB | PWR_FLAG_WU);
BSP_LED_On(LED5);
/* Reset was from wakeup from standy */
}
else
{
BSP_LED_Off(LED5);
}
BSP_UART_Init(115200);
uprintf("First LED is blinking in normal mode...\n\r");
uprintf("Press '1' to enter system in standby mode.\n\r");
uprintf("Wait 5s, RTC will wake-up system...\n\r");
// BSP_RTC_Init();
while(ugetche(NONE_BLOCKING) !='1')
{
BSP_LED_Toggle(LED6);
HAL_Delay(500);
}
uprintf("\n\nEnter Deep PowerDown mode...\n\r");
BSP_StandbyMode_PB();
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
BSP_LED_Toggle(LED6);
HAL_Delay(500);
}
/* USER CODE END 3 */
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch and Buffer caches
- 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.
- Low Level Initialization
*/
HAL_Init();
/* Configure LED3 and LED4 */
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
/* Configure the system clock to 180 MHz */
SystemClock_Config();
/* Enable Power Clock */
__HAL_RCC_PWR_CLK_ENABLE();
/* Check and handle if the system was resumed from StandBy mode */
if(__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET)
{
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);
/* Turn LED4 On */
BSP_LED_On(LED4);
}
/* Configure Key Button */
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_GPIO);
/* Wait until Key button is pressed to enter the Low Power mode */
while(BSP_PB_GetState(BUTTON_USER) != SET)
{
}
/* Loop while Key button is maintained pressed */
while(BSP_PB_GetState(BUTTON_USER) == SET)
{
}
/* Infinite loop */
while (1)
{
#if defined (SLEEP_MODE)
/* Sleep Mode Entry
- System Running at PLL (180MHz)
- 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 PC.13)
*/
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();
#endif
}
}
