void rtc_InitWakeUpInterrupt(){
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
// NVIC init
NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
// ext Interrupt 22 einstellen (fuer WakeUp)
EXTI_ClearITPendingBit(EXTI_Line22);
EXTI_InitStructure.EXTI_Line = EXTI_Line22;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
// zum einstellen muss Wakup disabled sein
RTC_WakeUpCmd(DISABLE);
// Teiler 16 => 32,768kHz:16 => 2048 Hz
RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div16);
// WakeUp Counter einstellen
RTC_SetWakeUpCounter(16); //set to 16 -> 128 interrupts per second (32768Hz / Div16 = 2048; 2948 / 128 = 16
// enable Interrupt
RTC_ITConfig(RTC_IT_WUT, ENABLE);
// enable Wakeup
RTC_WakeUpCmd(ENABLE);
}
void autowakeup_config()
{
RTC_WakeUpCmd(DISABLE);
RTC_WakeUpClockConfig(RTC_WakeUpClock_CK_SPRE_16bits);//configure 2
RTC_SetWakeUpCounter(0x0000);//1 second
RTC_WakeUpCmd(ENABLE);
}
/*
* Turn of timer tick and schedule wakeup
* after given ticks.
*/
void p_pos_powerTickSuspend(UVAR_t ticks)
{
/*
* First, systick off.
*/
SysTick->CTRL &= ~(SysTick_CTRL_TICKINT_Msk |
SysTick_CTRL_ENABLE_Msk);
/*
* Then, schedule RTC wakeup after ticks have passed.
*/
if (ticks == INFINITE)
return;
if (ticks / HZ > 65536) // max 18 hours
ticks = 65536 * HZ;
ticks -= PORTCFG_POWER_TICKLESS_SAFETY_MARGIN; // oscillator starts up 2 ms
RTC_WakeUpCmd(DISABLE);
if (ticks <= MS(10000)) {
// Wakeup timer ticks at 32768 / 8 = 4096 Hz
RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div8);
RTC_SetWakeUpCounter(4096 * ticks / HZ);
}
else {
// Wakeup timer ticks at 1 Hz
RTC_WakeUpClockConfig(RTC_WakeUpClock_CK_SPRE_16bits);
RTC_SetWakeUpCounter(ticks / HZ);
}
EXTI_ClearITPendingBit(EXTI_Line22);
RTC_ITConfig(RTC_IT_WUT, ENABLE);
RTC_ClearITPendingBit(RTC_IT_WUT);
RTC_ClearFlag(RTC_FLAG_WUTF);
NVIC_EnableIRQ(RTC_WKUP_IRQn);
startTime = rtcTimeNow();
RTC_WakeUpCmd(ENABLE);
}
/**
* @brief Configures the RTC Wakeup.
* @param None
* @retval None
*/
void RTC_Config(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/*!< Allow access to RTC */
PWR_RTCAccessCmd(ENABLE);
/*!< Reset RTC Domain */
RCC_RTCResetCmd(ENABLE);
RCC_RTCResetCmd(DISABLE);
/*!< LSE Enable */
RCC_LSEConfig(RCC_LSE_ON);
/*!< Wait till LSE is ready */
while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
{}
/*!< LCD Clock Source Selection */
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
/*!< Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/*!< Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* EXTI configuration *******************************************************/
EXTI_ClearITPendingBit(EXTI_Line20);
EXTI_InitStructure.EXTI_Line = EXTI_Line20;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
/* Enable the RTC Wakeup Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* RTC Wakeup Interrupt Generation: Clock Source: RTCDiv_16, Wakeup Time Base: 4s */
RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div16);
RTC_SetWakeUpCounter(0x1FFF);
/* Enable the Wakeup Interrupt */
RTC_ITConfig(RTC_IT_WUT, ENABLE);
}
/**
* @brief This function configures the system to enter Standby mode with RTC
* clocked by LSI for current consumption measurement purpose.
* STANDBY Mode with RTC clocked by LSI
* ========================================
* - RTC Clocked by LSI
* - IWDG OFF
* - Automatic Wakeup using RTC
* @param None
* @retval None
*/
void StandbyRTCMode_Measure(void)
{
/* Allow access to RTC */
PWR_BackupAccessCmd(ENABLE);
/* 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);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* RTC Wakeup Interrupt Generation: Clock Source: RTCCLK_Div16, Wakeup Time Base: ~5s
RTC Clock Source LSI ~32KHz
Wakeup Time Base = (16 / (LSI)) * WakeUpCounter
*/
RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div16);
RTC_SetWakeUpCounter(0x2800-1);
/* Enable the Wakeup Interrupt */
RTC_ITConfig(RTC_IT_WUT, ENABLE);
/* Enable Wakeup Counter */
RTC_WakeUpCmd(ENABLE);
/* Clear Wakeup flag */
PWR_ClearFlag(PWR_FLAG_WU);
/* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */
PWR_EnterSTANDBYMode();
/* Infinite loop */
while (1)
{
}
}
//------------------------------------------
void TM_RTC_Interrupts(uint32_t int_value) {
/* Clear pending bit */
EXTI->PR = 0x00400000;
/* Disable wakeup interrupt */
RTC_WakeUpCmd(DISABLE);
/* Disable RTC interrupt flag */
RTC_ITConfig(RTC_IT_WUT, DISABLE);
/* NVIC init for RTC */
NVIC_InitStruct.NVIC_IRQChannel = RTC_WKUP_IRQn;
NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = RTC_PRIORITY;
NVIC_InitStruct.NVIC_IRQChannelSubPriority = RTC_WAKEUP_SUBPRIORITY;
NVIC_InitStruct.NVIC_IRQChannelCmd = DISABLE;
NVIC_Init(&NVIC_InitStruct);
/* RTC connected to EXTI_Line22 */
EXTI_InitStruct.EXTI_Line = EXTI_Line22;
EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStruct.EXTI_LineCmd = DISABLE;
EXTI_Init(&EXTI_InitStruct);
if (int_value != TM_RTC_Int_Disable) {
/* Enable NVIC */
NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStruct);
/* Enable EXT1 interrupt */
EXTI_InitStruct.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStruct);
/* First disable wake up command */
RTC_WakeUpCmd(DISABLE);
/* Clock divided by 8, 32768 / 8 = 4096 */
/* 4096 ticks for 1second interrupt */
RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div8);
/* Set RTC wakeup counter */
RTC_SetWakeUpCounter(0x0FFF * int_value);
/* Enable wakeup interrupt */
RTC_ITConfig(RTC_IT_WUT, ENABLE);
/* Enable wakeup command */
RTC_WakeUpCmd(ENABLE);
}
}
/**
* @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);
}
void rtc_init_counter_mode() {
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
RTC_InitTypeDef RTC_InitStructure;
/* Enable the PWR clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/* Allow access to RTC */
PWR_RTCAccessCmd(ENABLE);
/* Reset RTC Domain */
RCC_RTCResetCmd(ENABLE);
RCC_RTCResetCmd(DISABLE);
/* 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 );
/* Set the RTC time base to 1s */
RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
RTC_InitStructure.RTC_AsynchPrediv = 0x7F;
RTC_InitStructure.RTC_SynchPrediv = 0x00FF;
RTC_Init(&RTC_InitStructure);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronization */
RTC_WaitForSynchro();
/* EXTI configuration *******************************************************/
EXTI_ClearITPendingBit(EXTI_Line20 );
EXTI_InitStructure.EXTI_Line = EXTI_Line20;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
/* Enable the RTC Wakeup Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* Configure the RTC WakeUp Clock source: CK_SPRE (1Hz) */
RTC_WakeUpClockConfig(RTC_WakeUpClock_CK_SPRE_16bits );
RTC_SetWakeUpCounter(0x0);
/* Enable the RTC Wakeup Interrupt */
RTC_ITConfig(RTC_IT_WUT, ENABLE);
rtc_disable_interrupt();
/* Enable Wakeup Counter */
RTC_WakeUpCmd(ENABLE);
}
/**
* @brief This function configures the system to enter Stop mode with RTC
* clocked by LSI for current consumption measurement purpose.
* STOP Mode with RTC clocked by LSI
* =====================================
* - 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 Wakeup using RTC clocked by LSI (~5s)
* @param None
* @retval None
*/
void StopMode_Measure(void)
{
__IO uint32_t index = 0;
GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
/* Allow access to RTC */
PWR_BackupAccessCmd(ENABLE);
/* 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);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* Configure all GPIO as analog to reduce current consumption on non used IOs */
/* Enable GPIOs clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA | RCC_AHBPeriph_GPIOB | RCC_AHBPeriph_GPIOC |
RCC_AHBPeriph_GPIOD | RCC_AHBPeriph_GPIOF , ENABLE);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIO_Init(GPIOD, &GPIO_InitStructure);
GPIO_Init(GPIOF, &GPIO_InitStructure);
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* Disable GPIOs clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA |RCC_AHBPeriph_GPIOB | RCC_AHBPeriph_GPIOC |
RCC_AHBPeriph_GPIOD | RCC_AHBPeriph_GPIOF, DISABLE);
/* Configure EXTI Line20 corresponding to the RTC Wakeup interrupt */
EXTI_ClearITPendingBit(EXTI_Line20);
EXTI_InitStructure.EXTI_Line = EXTI_Line20;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
/* NVIC configuration */
NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* RTC Wakeup Interrupt Generation: Clock Source: RTCCLK_Div16, Wakeup Time Base: ~5s
RTC Clock Source LSI ~32KHz
Wakeup Time Base = (16 / (LSI)) * WakeUpCounter
*/
RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div16);
RTC_SetWakeUpCounter(0x2800-1);
/* Enable the Wakeup Interrupt */
RTC_ITConfig(RTC_IT_WUT, ENABLE);
/* Enable Wakeup Counter */
RTC_WakeUpCmd(ENABLE);
/* Enter Stop Mode */
PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
/* Initialize LED4 */
STM_EVAL_LEDInit(LED4);
/* Infinite loop */
while (1)
{
/* Toggle The LED4 */
STM_EVAL_LEDToggle(LED4);
/* Inserted Delay */
for(index = 0; index < 0x5FFFF; index++);
}
}
/**
* @brief Configures the RTC clock source.
* @param None
* @retval None
*/
void RTC_Config(void)
{
EXTI_InitTypeDef EXTI_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
__IO uint32_t AsynchPrediv = 0, SynchPrediv = 0;
/* 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();
/* RTC Wakeup Interrupt Generation: Clock Source: RTCCLK_Div16, Wakeup Time Base: ~4s
Wakeup Time Base = (16 / (LSE or LSI)) * WakeUpCounter
*/
RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div16);
RTC_SetWakeUpCounter(0x1FFF);
/* Enable the Wakeup Interrupt */
RTC_ITConfig(RTC_IT_WUT, ENABLE);
/* Connect EXTI_Line22 to the RTC Wakeup event */
EXTI_ClearITPendingBit(EXTI_Line22);
EXTI_InitStructure.EXTI_Line = EXTI_Line22;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
/* Enable the RTC Wakeup Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
/**
* @brief This function configures the system to enter Stop mode with RTC
* clocked by LSE or LSI for current consumption measurement purpose.
* STOP Mode with RTC clocked by LSE/LSI
* =====================================
* - RTC Clocked by LSE or 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 (~20s)
* @param None
* @retval None
*/
void StopMode_Measure(void)
{
__IO uint32_t index = 0;
GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
/* 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();
/* Configure all GPIO as analog to reduce current consumption on non used IOs */
/* Enable GPIOs clock */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC |
RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_GPIOE | RCC_AHB1Periph_GPIOF |
RCC_AHB1Periph_GPIOG | RCC_AHB1Periph_GPIOH | RCC_AHB1Periph_GPIOI, ENABLE);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIO_Init(GPIOD, &GPIO_InitStructure);
GPIO_Init(GPIOE, &GPIO_InitStructure);
GPIO_Init(GPIOF, &GPIO_InitStructure);
GPIO_Init(GPIOG, &GPIO_InitStructure);
GPIO_Init(GPIOH, &GPIO_InitStructure);
GPIO_Init(GPIOI, &GPIO_InitStructure);
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* Disable GPIOs clock */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC |
RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_GPIOE | RCC_AHB1Periph_GPIOF |
RCC_AHB1Periph_GPIOG | RCC_AHB1Periph_GPIOH | RCC_AHB1Periph_GPIOI, DISABLE);
/* EXTI configuration *******************************************************/
EXTI_ClearITPendingBit(EXTI_Line22);
EXTI_InitStructure.EXTI_Line = EXTI_Line22;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
/* Enable the RTC Wakeup Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* 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);
/* Enable the Wakeup Interrupt */
RTC_ITConfig(RTC_IT_WUT, ENABLE);
/* Enable Wakeup Counter */
RTC_WakeUpCmd(ENABLE);
/* FLASH Deep Power Down Mode enabled */
PWR_FlashPowerDownCmd(ENABLE);
/* Enter Stop Mode */
PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
/* Initialize LED1 on EVAL board */
STM_EVAL_LEDInit(LED1);
/* Infinite loop */
while (1)
{
/* Toggle The LED1 */
STM_EVAL_LEDToggle(LED1);
/* Inserted Delay */
for(index = 0; index < 0x5FF; index++);
}
}
/**
* @brief Configure the RTC peripheral by selecting the clock source.
* @param None
* @retval None
*/
void RTC_Config(void) {
RTC_DateTypeDef RTC_DateStructure;
RTC_TimeTypeDef RTC_TimeStructure;
RTC_InitTypeDef RTC_InitStructure;
RTC_AlarmTypeDef RTC_AlarmStructure;
/* 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);
/* ck_spre(1Hz) = RTCCLK(LSI) /(uwAsynchPrediv + 1)*(uwSynchPrediv + 1)*/
uwSynchPrediv = 0xFF;
uwAsynchPrediv = 0x7F;
printf("\r\n * LSI used as RTC source clock");
#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);
/* ck_spre(1Hz) = RTCCLK(LSE) /(uwAsynchPrediv + 1)*(uwSynchPrediv + 1)*/
uwSynchPrediv = 0xFF;
uwAsynchPrediv = 0x7F;
printf("\r\n * LSE used as RTC source clock");
#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();
/* Configure the RTC data register and RTC prescaler */
RTC_InitStructure.RTC_AsynchPrediv = uwAsynchPrediv;
RTC_InitStructure.RTC_SynchPrediv = uwSynchPrediv;
RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
RTC_Init(&RTC_InitStructure);
/* Set the alarm 00h:00min:00s */
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_H12_AM;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = 0x00;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = 0x00;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = 0x00;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay;
/* Configure the RTC Alarm A register */
RTC_SetAlarm(RTC_Format_BCD, RTC_Alarm_A, &RTC_AlarmStructure);
/* Configure the RTC WakeUp Clock source: CK_SPRE (1Hz) */
RTC_WakeUpClockConfig(RTC_WakeUpClock_CK_SPRE_16bits);
RTC_SetWakeUpCounter(0x0);
/* Enable RTC Wakeup and RTC Alarm A Interrupt */
RTC_ITConfig(RTC_IT_WUT | RTC_IT_ALRA, ENABLE);
/* Enable Wakeup Counter */
RTC_WakeUpCmd(ENABLE);
/* Enable the alarm */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
RTC_ClearFlag(RTC_FLAG_ALRAF);
/* Set the date: Saturday April 20th 2013 */
RTC_DateStructure.RTC_Year = 0x13;
RTC_DateStructure.RTC_Month = RTC_Month_April;
RTC_DateStructure.RTC_Date = 0x14;
RTC_DateStructure.RTC_WeekDay = RTC_Weekday_Saturday;
RTC_SetDate(RTC_Format_BCD, &RTC_DateStructure);
/* Set the time to 00h 00mn 00s AM */
RTC_TimeStructure.RTC_H12 = RTC_H12_AM;
RTC_TimeStructure.RTC_Hours = 0x00;
RTC_TimeStructure.RTC_Minutes = 0x00;
RTC_TimeStructure.RTC_Seconds = 0x00;
RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure);
/* Indicator for the RTC configuration */
RTC_WriteBackupRegister(RTC_BKP_DR0, 0x32F2);
}
void TM_RTC_Interrupts(TM_RTC_Int_t int_value) {
uint32_t int_val;
/* Clear pending bit */
EXTI_ClearITPendingBit(EXTI_Line22);
/* NVIC init for RTC */
NVIC_InitStruct.NVIC_IRQChannel = RTC_WKUP_IRQn;
NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = RTC_PRIORITY;
NVIC_InitStruct.NVIC_IRQChannelSubPriority = RTC_WAKEUP_SUBPRIORITY;
/* RTC connected to EXTI_Line22 */
EXTI_InitStruct.EXTI_Line = EXTI_Line22;
EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising;
if (int_value == TM_RTC_Int_Disable) {
/* Disable wakeup interrupt */
RTC_WakeUpCmd(DISABLE);
/* Disable RTC interrupt flag */
RTC_ITConfig(RTC_IT_WUT, DISABLE);
/* Disable NVIC */
NVIC_InitStruct.NVIC_IRQChannelCmd = DISABLE;
NVIC_Init(&NVIC_InitStruct);
/* Disable EXT1 interrupt */
EXTI_InitStruct.EXTI_LineCmd = DISABLE;
EXTI_Init(&EXTI_InitStruct);
} else {
/* Enable NVIC */
NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStruct);
/* Enable EXT1 interrupt */
EXTI_InitStruct.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStruct);
/* First disable wake up command */
RTC_WakeUpCmd(DISABLE);
if (int_value == TM_RTC_Int_60s) {
int_val = 0x3BFFF; /* 60 seconds = 60 * 4096 / 1 = 245760 */
} else if (int_value == TM_RTC_Int_30s) {
int_val = 0x1DFFF; /* 30 seconds */
} else if (int_value == TM_RTC_Int_15s) {
int_val = 0xEFFF; /* 15 seconds */
} else if (int_value == TM_RTC_Int_10s) {
int_val = 0x9FFF; /* 10 seconds */
} else if (int_value == TM_RTC_Int_5s) {
int_val = 0x4FFF; /* 5 seconds */
} else if (int_value == TM_RTC_Int_2s) {
int_val = 0x1FFF; /* 2 seconds */
} else if (int_value == TM_RTC_Int_1s) {
int_val = 0x0FFF; /* 1 second */
} else if (int_value == TM_RTC_Int_500ms) {
int_val = 0x7FF; /* 500 ms */
} else if (int_value == TM_RTC_Int_250ms) {
int_val = 0x3FF; /* 250 ms */
} else if (int_value == TM_RTC_Int_125ms) {
int_val = 0x1FF; /* 125 ms */
}
/* Clock divided by 8, 32768 / 8 = 4068 */
/* 4096 ticks for 1second interrupt */
RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div8);
/* Set RTC wakeup counter */
RTC_SetWakeUpCounter(int_val);
/* Enable wakeup interrupt */
RTC_ITConfig(RTC_IT_WUT, ENABLE);
/* Enable wakeup command */
RTC_WakeUpCmd(ENABLE);
}
}
void configureWakeup (void)
{
/* Declare initialisation structures for (NVIC) and external interupt (EXTI) */
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
/* Clear IT pending bit from external interrupt Line 20 */
EXTI_ClearITPendingBit(EXTI_Line20);
/* Initialise EXTI using its init structure */
EXTI_InitStructure.EXTI_Line = EXTI_Line20; // interrupt generated on RTC Wakeup event (Line 20)
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt; // Use EXTI line as interrupt
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising; // Trigg interrupt on rising edge detection
EXTI_InitStructure.EXTI_LineCmd = ENABLE; // Enable EXTI line
EXTI_Init(&EXTI_InitStructure);
/* Initialise the NVIC interrupts (IRQ) using its init structure */
NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn; // set IRQ channel to RTC Wakeup Interrupt
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; // set channel Preemption priority to 0
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; // set channel sub priority to 0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; // Enable channel
NVIC_Init(&NVIC_InitStructure);
/* Clear Wake-up flag */
PWR->CR |= PWR_CR_CWUF;
/* Enable PWR clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/* Allow access to RTC */
PWR_RTCAccessCmd(ENABLE);
/* Enable Low Speed External clock */
RCC_LSEConfig(RCC_LSE_ON);
/* Wait till LSE is ready */
while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET);
/* Select LSE clock as RCC Clock source */
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* Select 1Hz clock for RTC wake up*/
RTC_WakeUpClockConfig(RTC_WakeUpClock_CK_SPRE_16bits);
/* Set Wakeup auto-reload value to 2 sec */
RTC_SetWakeUpCounter(1);
/* Clear RTC Interrupt pending bit */
RTC_ClearITPendingBit(RTC_IT_WUT);
/* Clear EXTI line20 Interrupt pending bit */
EXTI_ClearITPendingBit(EXTI_Line20);
/* Enable the Wakeup Interrupt */
RTC_ITConfig(RTC_IT_WUT, ENABLE);
}
/**
* @brief Configure the RTC peripheral by selecting the clock source.
* @param None
* @retval None
*/
void RTC_Config(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
/* Enable the PWR clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG , ENABLE);
/* Allow access to RTC */
//PWR_RTCAccessCmd(ENABLE);
//Enable the LSE OSC
RCC_LSEConfig(RCC_LSE_ON);
//wait until LSE is ready
while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) {}
//Select RTC clk source
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
//SynchPrediv = 0xFF;
//AsynchPrediv = 0x7F;
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
RTC_InitStructure.RTC_AsynchPrediv = 0x7F;
RTC_InitStructure.RTC_SynchPrediv = 0xFF; /* (32KHz / 128) - 1 = 0xFF*/
RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
RTC_Init(&RTC_InitStructure);
RTC_WakeUpCmd(DISABLE);
/* EXTI configuration *******************************************************/
EXTI_ClearITPendingBit(EXTI_Line20);
EXTI_InitStructure.EXTI_Line = EXTI_Line20;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
/* Enable the RTC Wakeup Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
NVIC_SetPriority(RTC_WKUP_IRQn, INT_PRIORITY_WKUP);
//RTCCLK=32768Hz ; div=16 =>2048Hz
RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div16);
//div 256 =>8Hz ~ 125ms
RTC_SetWakeUpCounter(0xFF);
RTC_ClearITPendingBit(RTC_IT_WUT);
EXTI_ClearITPendingBit(EXTI_Line20);
/* Enable the RTC Wakeup Interrupt */
RTC_ITConfig(RTC_IT_WUT, ENABLE);
/* Enable Wakeup Counter */
RTC_WakeUpCmd(ENABLE);
//PWR_RTCAccessCmd(DISABLE);
//disable PWR clock
//RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, DISABLE);
}
void RTC_Configuration(void)
{
/* Enable the PWR APB1 Clock Interface */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/* Allow access to BKP Domain */
PWR_BackupAccessCmd(ENABLE);
if (RTC_ReadBackupRegister(RTC_BKP_DR2) != 0xA5A5) {
/* 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();
/* Allow access to BKP Domain */
PWR_BackupAccessCmd(ENABLE);
/* Write to the first RTC Backup Data Register */
RTC_WriteBackupRegister(RTC_BKP_DR2,0xA5A5);
/* Set the Time */
RTC_TimeStructure.RTC_Hours = 22;
RTC_TimeStructure.RTC_Minutes = 11;
RTC_TimeStructure.RTC_Seconds = 00;
/* Set the Date */
RTC_DateStructure.RTC_Month = 4;
RTC_DateStructure.RTC_Date = 29;
RTC_DateStructure.RTC_Year = 11;
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_BIN, &RTC_TimeStructure);
RTC_SetDate(RTC_Format_BIN, &RTC_DateStructure);
#if 0
/* 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);
#endif
/* Backup SRAM ***************************************************************/
/* Enable BKPRAM Clock */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_BKPSRAM, ENABLE);
/* 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)
{
}
}
else{
/* Enable the PWR clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/* Allow access to RTC */
PWR_BackupAccessCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* Clear the Wakeup Interrupt */
RTC_ClearITPendingBit(RTC_IT_WUT);
/* Backup SRAM ***************************************************************/
/* Enable BKPSRAM Clock */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_BKPSRAM, ENABLE);
}
}
void EnRtcInter(void){
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
RTC_InitTypeDef RTC_InitStructure;
/* Enable the PWR clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/* Allow access to RTC */
PWR_RTCAccessCmd(ENABLE);
/* 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);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* Calendar Configuration */
RTC_InitStructure.RTC_AsynchPrediv = 0x7F;
RTC_InitStructure.RTC_SynchPrediv = 0x120; /* (37KHz / 128) - 1 = 0x120*/
RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
RTC_Init(&RTC_InitStructure);
/*
To enable the RTC Wakeup interrupt, the following sequence is required:
1. Configure and enable the EXTI Line 20 in interrupt mode and select the rising edge
sensitivity.
2. Configure and enable the RTC_WKUP IRQ channel in the NVIC.
3. Configure the RTC to generate the RTC wakeup timer event.
System reset, as well as low power modes (Sleep, Stop and Standby) have no influence on
the wakeup timer.
*/
/* EXTI configuration *******************************************************/
EXTI_ClearITPendingBit(EXTI_Line20);
EXTI_InitStructure.EXTI_Line = EXTI_Line20;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
/* Enable the RTC Wakeup Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
RTC_WakeUpCmd(DISABLE);
PWR_RTCAccessCmd(ENABLE);
RTC_WakeUpClockConfig(RTC_WakeUpClock_CK_SPRE_16bits);
RTC_SetWakeUpCounter(readintvalue(SLEEPTIME_add)); //0x01f4
//The WUTF flag must then be cleared by software.
RTC_ClearITPendingBit(RTC_IT_WUT); //ClearITPendingBit clears also the flag
//RTC_ClearFlag(RTC_FLAG_WUTF); //MANDATORY!
RTC_ITConfig(RTC_IT_WUT, ENABLE); //enable interrupt
RTC_WakeUpCmd(ENABLE);
PWR_RTCAccessCmd(DISABLE); //just in case
}
/**
* @brief This function configures the system to enter Standby mode with RTC
* clocked by LSI for current consumption measurement purpose.
* STANDBY Mode with RTC clocked by LSI
* ====================================
* - RTC Clocked by LSI
* - IWDG OFF
* - Current Consumption ~1.1uA
* - Automatic Wakeup using RTC clocked by LSI (after ~4s)
* @param None
* @retval None
*/
void StandbyRTCLSIMode_Measure(void)
{
/* Configure Key Button*/
STM_EVAL_PBInit(BUTTON_KEY,BUTTON_MODE_GPIO);
/* Wait Until Key button pressed */
while(STM_EVAL_PBGetState(BUTTON_KEY) == RESET)
{
}
/* Wait Until Key button pressed */
while(STM_EVAL_PBGetState(BUTTON_KEY) != RESET)
{
}
/* Allow access to RTC */
PWR_RTCAccessCmd(ENABLE);
/*!< LSI Enable */
RCC_LSICmd(ENABLE);
/*!< Wait till LSI is ready */
while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET)
{}
/*!< RTC Clock Source Selection */
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* Enable Ultra low power mode */
PWR_UltraLowPowerCmd(ENABLE);
/* RTC Wakeup Interrupt Generation: Clock Source: RTCCLK_Div16, Wakeup Time Base: ~4s
RTC Clock Source LSI ~37KHz
*/
RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div16);
RTC_SetWakeUpCounter(0x2421);
/* Clear PWR WakeUp flag */
PWR_ClearFlag(PWR_FLAG_WU);
/* Clear RTC WakeUp (WUTF) flag */
RTC_ClearFlag(RTC_FLAG_WUTF);
/* Enable the Wakeup Interrupt */
RTC_ITConfig(RTC_IT_WUT, ENABLE);
/* Enable Wakeup Counter */
RTC_WakeUpCmd(ENABLE);
/* Request to enter STANDBY mode */
PWR_EnterSTANDBYMode();
/* Infinite loop */
while (1)
{
}
}
/**
* @brief This function configures the system to enter Stop mode with RTC
* clocked by LSI for current consumption measurement purpose.
* STOP Mode with RTC clocked by LSI
* =================================
* - RTC Clocked by LSI
* - Regulator in LP mode
* - HSI and HSE OFF
* - No IWDG
* - Current Consumption ~1.3uA
* - Automatic Wakeup using RTC clocked by LSI (after ~4s)
* @param None
* @retval None
*/
void StopRTCLSIMode_Measure(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
/* Allow access to RTC */
PWR_RTCAccessCmd(ENABLE);
/*!< LSI Enable */
RCC_LSICmd(ENABLE);
/*!< Wait till LSI is ready */
while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET)
{}
/*!< RTC Clock Source Selection */
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* Configure all GPIO as analog to reduce current consumption on non used IOs */
/* Enable GPIOs clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA | RCC_AHBPeriph_GPIOB | RCC_AHBPeriph_GPIOC |
RCC_AHBPeriph_GPIOD | RCC_AHBPeriph_GPIOE | RCC_AHBPeriph_GPIOH |
RCC_AHBPeriph_GPIOF | RCC_AHBPeriph_GPIOG, ENABLE);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_40MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIO_Init(GPIOD, &GPIO_InitStructure);
GPIO_Init(GPIOE, &GPIO_InitStructure);
GPIO_Init(GPIOH, &GPIO_InitStructure);
GPIO_Init(GPIOG, &GPIO_InitStructure);
GPIO_Init(GPIOF, &GPIO_InitStructure);
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* Disable GPIOs clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA | RCC_AHBPeriph_GPIOB | RCC_AHBPeriph_GPIOC |
RCC_AHBPeriph_GPIOD | RCC_AHBPeriph_GPIOE | RCC_AHBPeriph_GPIOH |
RCC_AHBPeriph_GPIOF | RCC_AHBPeriph_GPIOG, DISABLE);
/* Configure Key Button*/
STM_EVAL_PBInit(BUTTON_KEY,BUTTON_MODE_GPIO);
/* Wait Until Key button pressed */
while(STM_EVAL_PBGetState(BUTTON_KEY) == RESET)
{
}
/* Wait Until Key button pressed */
while(STM_EVAL_PBGetState(BUTTON_KEY) != RESET)
{
}
/* EXTI configuration *******************************************************/
EXTI_ClearITPendingBit(EXTI_Line20);
EXTI_InitStructure.EXTI_Line = EXTI_Line20;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
/* Enable the RTC Wakeup Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* RTC Wakeup Interrupt Generation: Clock Source: RTCCLK_Div16, Wakeup Time Base: ~4s
RTC Clock Source LSI ~37KHz
*/
RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div16);
RTC_SetWakeUpCounter(0x2421);
/* Enable the Wakeup Interrupt */
RTC_ITConfig(RTC_IT_WUT, ENABLE);
/* Enable Ultra low power mode */
PWR_UltraLowPowerCmd(ENABLE);
/* Enable Wakeup Counter */
RTC_WakeUpCmd(ENABLE);
/* Enter Stop Mode */
PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
/* Infinite loop */
while (1)
{
/* Toggle The LED1 */
STM_EVAL_LEDToggle(LED1);
/* Inserted Delay */
for(index = 0; index < 0x5FF; index++);
}
}
////////////////////////////////////////
// Секундный тик
////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void RTC_Alarm_IRQHandler(void) { // Тик каждые 4 секунды
int i;
#ifdef debug
Wakeup.rtc_wakeup++;
#endif
if(RTC_GetITStatus(RTC_IT_ALRA) != RESET)
{
RTC_ClearITPendingBit(RTC_IT_ALRA);
EXTI_ClearITPendingBit(EXTI_Line17);
if(!poweroff_state)
{
Set_next_alarm_wakeup(); // установить таймер просыпания на +4 секунды
DataUpdate.Need_display_update=ENABLE;
if(Power.USB_active)
{
USB_not_active++; // Счетчик неактивности USB
madorc_impulse+=Detector_massive[Detector_massive_pointer]; // Счетчик импульсов для передачи по USB
}
// Счетчик времени для обновления напряжения АКБ (каждые 4 минуты)
if(DataUpdate.Batt_update_time_counter>75)
{
DataUpdate.Need_batt_voltage_update=ENABLE;
DataUpdate.Batt_update_time_counter=0;
} else DataUpdate.Batt_update_time_counter++;
// Счетчик времени для обновления счетчика импульсов накачки
if(DataUpdate.pump_counter_update_time>14)
{
#ifdef debug
Wakeup.total_wakeup=0;
Wakeup.total_cycle=0;
Wakeup.rtc_wakeup=0;
Wakeup.tim9_wakeup=0;
Wakeup.pump_wakeup=0;
Wakeup.comp_wakeup=0;
Wakeup.sensor_wakeup=0;
#endif
if(!Power.USB_active)madorc_impulse=0;
pump_counter_avg_impulse_by_1sec[1]=pump_counter_avg_impulse_by_1sec[0];
pump_counter_avg_impulse_by_1sec[0]=0;
DataUpdate.pump_counter_update_time=0;
if(pump_counter_avg_impulse_by_1sec[1]==0) //затычка на случай глюка с накачкой
{
dac_init();
Pump_now(DISABLE);
while(RTC_WakeUpCmd(DISABLE)!=SUCCESS);
RTC_SetWakeUpCounter(0xF96); // Установить таймаут просыпания = 2 секунды
current_pulse_count=0;
while(RTC_WakeUpCmd(ENABLE)!=SUCCESS);
}
} else DataUpdate.pump_counter_update_time++;
// Счетчик дней
if(DataUpdate.days_sec_count>=24600) // каждые 24 часа минут
{
DataUpdate.days_sec_count=0;
working_days++;
} else DataUpdate.days_sec_count++;
// Сдвиг массива дозы
if(DataUpdate.doze_sec_count>=150) // каждые 10 минут (150)
{
DataUpdate.Need_update_mainscreen_counters=ENABLE;
// -----------------------------------------------------
DataUpdate.doze_count++;
if(DataUpdate.doze_count>=doze_length) // Запись страницы во Flash
//if(DataUpdate.doze_count>1) // Запись страницы во Flash
{
DataUpdate.doze_count=0;
flash_write_page(DataUpdate.current_flash_page);
DataUpdate.current_flash_page++;
if(DataUpdate.current_flash_page > ((FLASH_END_ADDR-FLASH_START_ADDR)/FLASH_PAGE_SIZE)) // если за границами диапазона
DataUpdate.current_flash_page=0;
}
// -----------------------------------------------------
for(i=doze_length;i>0;i--)
{
ram_Doze_massive[i]=ram_Doze_massive[i-1]; // сдвиг массива дозы
ram_max_fon_massive[i]=ram_max_fon_massive[i-1]; // сдвиг массива максимального фона
}
ram_Doze_massive[0]=0;
ram_max_fon_massive[0]=0;
DataUpdate.doze_sec_count=1; //// !!!!! 0
} else DataUpdate.doze_sec_count++;
////////////////////////////////////////////////////
////////////////////////////////////////////////////
if(Detector_massive[Detector_massive_pointer]>9)
{
if(Detector_massive[Detector_massive_pointer]>199) // деление на 9 при фоне более 10 000
{
if(auto_speedup_factor!=10)auto_speedup_factor=9;
} else
{
if(Detector_massive[Detector_massive_pointer]>99) // деление на 5 при фоне более 5 000
{
if(auto_speedup_factor!=5)auto_speedup_factor=5;
} else
{
if(Detector_massive[Detector_massive_pointer]>19) // деление на 3 при фоне более 1 000
{
if(auto_speedup_factor!=3)auto_speedup_factor=3;
} else
{ // деление на 2 при фоне более 500
if(auto_speedup_factor!=2)auto_speedup_factor=2;
}
}
}
if(auto_speedup_factor!=1)recalculate_fon(); // пересчет фона, если активированно ускорение
} else
{ // если ускорение не требуется
if(auto_speedup_factor!=1){auto_speedup_factor=1;recalculate_fon();}
else
{ fon_level+=Detector_massive[Detector_massive_pointer];}
}
Detector_massive_pointer++;
if(Detector_massive_pointer>=(Settings.Second_count>>2))
{
if(auto_speedup_factor==1)fon_level-=Detector_massive[0];
Detector_massive[0]=0;
Detector_massive_pointer=0;
}else
{
if(auto_speedup_factor==1)fon_level-=Detector_massive[Detector_massive_pointer];
static unsigned long stop_mode_power_down_hook( unsigned long sleep_ms )
{
unsigned long retval;
unsigned long wut_ticks_passed;
unsigned long scale_factor = 0;
UNUSED_PARAMETER(sleep_ms);
UNUSED_PARAMETER(rtc_timeout_start_time);
UNUSED_PARAMETER(scale_factor);
if ( ( ( SCB->SCR & (unsigned long)SCB_SCR_SLEEPDEEP_Msk) != 0) && sleep_ms < 5 ){
SCB->SCR &= (~((unsigned long)SCB_SCR_SLEEPDEEP_Msk));
__asm("wfi");
SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
/* Note: We return 0 ticks passed because system tick is still going when wfi instruction gets executed */
ENABLE_INTERRUPTS;
return 0;
}
if ( ( ( SCB->SCR & (unsigned long)SCB_SCR_SLEEPDEEP_Msk) ) != 0 )
{
/* pick up the appropriate prescaler for a requested delay */
select_wut_prescaler_calculate_wakeup_time(&rtc_timeout_start_time, sleep_ms, &scale_factor );
DISABLE_INTERRUPTS;
SysTick->CTRL &= (~(SysTick_CTRL_TICKINT_Msk|SysTick_CTRL_ENABLE_Msk)); /* systick IRQ off */
RTC_ITConfig(RTC_IT_WUT, ENABLE);
EXTI_ClearITPendingBit( RTC_INTERRUPT_EXTI_LINE );
PWR_ClearFlag(PWR_FLAG_WU);
RTC_ClearFlag(RTC_FLAG_WUTF);
RTC_SetWakeUpCounter( rtc_timeout_start_time );
RTC_WakeUpCmd( ENABLE );
platform_rtc_enter_powersave();
DBGMCU->CR |= 0x03; /* Enable debug in stop mode */
/* This code will be running with BASEPRI register value set to 0, the main intention behind that is that */
/* all interrupts must be allowed to wake the CPU from the power-down mode */
/* the PRIMASK is set to 1( see DISABLE_INTERRUPTS), thus we disable all interrupts before entering the power-down mode */
/* This may sound contradictory, however according to the ARM CM3 documentation power-management unit */
/* takes into account only the contents of the BASEPRI register and it is an external from the CPU core unit */
/* PRIMASK register value doesn't affect its operation. */
/* So, if the interrupt has been triggered just before the wfi instruction */
/* it remains pending and wfi instruction will be treated as a nop */
__asm("wfi");
/* After CPU exits powerdown mode, the processer will not execute the interrupt handler(PRIMASK is set to 1) */
/* Disable rtc for now */
RTC_WakeUpCmd( DISABLE );
RTC_ITConfig(RTC_IT_WUT, DISABLE);
/* Initialise the clocks again */
init_clocks( );
/* Enable CPU ticks */
SysTick->CTRL |= (SysTick_CTRL_TICKINT_Msk|SysTick_CTRL_ENABLE_Msk);
/* Get the time of how long the sleep lasted */
wut_ticks_passed = rtc_timeout_start_time - RTC_GetWakeUpCounter();
UNUSED_VARIABLE(wut_ticks_passed);
platform_rtc_exit_powersave( sleep_ms, (uint32_t *)&retval );
/* as soon as interrupts are enabled, we will go and execute the interrupt handler */
/* which triggered a wake up event */
ENABLE_INTERRUPTS;
wake_up_interrupt_triggered = false;
UNUSED_VARIABLE(wake_up_interrupt_triggered);
return retval;
}
else
{
UNUSED_PARAMETER(wut_ticks_passed);
ENABLE_INTERRUPTS;
__asm("wfi");
/* Note: We return 0 ticks passed because system tick is still going when wfi instruction gets executed */
return 0;
}
}
static void RTC_Config32768Internal(void) {
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
RTC_DateTypeDef RTC_DateStruct;
//uint8_t yr;
/* Enable the PWR clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/* SYSCFG Peripheral clock enable */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
PWR_DeInit();
/* Allow access to RTC */
PWR_RTCAccessCmd(ENABLE);
/* LSI used as RTC source clock */
/* The RTC Clock may varies due to LSI frequency dispersion. */
/* Enable the LSI OSC */
//RCC_LSICmd(ENABLE);
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
RCC_LSEConfig(RCC_LSE_ON);
/* Wait till LSI is ready */
//while(RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET)
while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == 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();
// LSE 32768
RTC_InitStructure.RTC_AsynchPrediv = 127;
RTC_InitStructure.RTC_SynchPrediv = 255;
/* Calendar Configuration with LSI supposed at 37KHz */
//RTC_InitStructure.RTC_AsynchPrediv = 124;
//RTC_InitStructure.RTC_SynchPrediv = 295; /* (32KHz / 128) - 1 = 0xFF*/
RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
RTC_Init(&RTC_InitStructure);
/* Set the time to 05h 20mn 00s AM */
RTC_TimeStructure.RTC_H12 = RTC_H12_PM;
RTC_TimeStructure.RTC_Hours = 0x23;
RTC_TimeStructure.RTC_Minutes = 0x59;
RTC_TimeStructure.RTC_Seconds = 0x50;
RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure);
RTC_DateStruct.RTC_Year = 14;
RTC_DateStruct.RTC_Month = 10;
RTC_DateStruct.RTC_Date = 4;
RTC_DateStruct.RTC_WeekDay = 6;
//day = 5;
RTC_SetDate(RTC_Format_BIN, &RTC_DateStruct);
//RTC_GetDate(RTC_Format_BCD, &RTC_DateStruct);
//yr = RTC_DateStruct.RTC_Year;
/* EXTI configuration *******************************************************/
EXTI_ClearITPendingBit(EXTI_Line20);
EXTI_InitStructure.EXTI_Line = EXTI_Line20;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
// Configuring RTC_WakeUp interrupt
NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
// RTC Wakeup Configuration
RTC_WakeUpClockConfig(RTC_WakeUpClock_CK_SPRE_16bits);
// RTC Set WakeUp Counter
RTC_SetWakeUpCounter(0);
// Enabling RTC_WakeUp interrupt
RTC_ITConfig(RTC_IT_WUT, ENABLE);
// Disabling Alarm Flags
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
RTC_AlarmCmd(RTC_Alarm_B, DISABLE);
// RTC Enable the Wakeup Function
RTC_WakeUpCmd(ENABLE);
}
/**
* @brief Configures the RTC peripheral by selecting the clock source.
* @param None
* @retval None
*/
static void RTC_Config(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
/* Enable the PWR clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/* Allow access to RTC */
PWR_BackupAccessCmd(ENABLE);
/* 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);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* Calendar Configuration with LSI supposed at 32KHz */
RTC_InitStructure.RTC_AsynchPrediv = 0x7F;
RTC_InitStructure.RTC_SynchPrediv = 0xFF; /* (32KHz / 128) - 1 = 0xFF*/
RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
RTC_Init(&RTC_InitStructure);
/* EXTI configuration *******************************************************/
EXTI_ClearITPendingBit(EXTI_Line22);
EXTI_InitStructure.EXTI_Line = EXTI_Line22;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
/* Enable the RTC Wakeup Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* Configure the RTC WakeUp Clock source: CK_SPRE (1Hz) */
RTC_WakeUpClockConfig(RTC_WakeUpClock_CK_SPRE_16bits);
RTC_SetWakeUpCounter(0x0);
/* Enable the RTC Wakeup Interrupt */
RTC_ITConfig(RTC_IT_WUT, ENABLE);
/* Enable Wakeup Counter */
RTC_WakeUpCmd(ENABLE);
}
/*
* This tick module runs with or without periodic tick. If periodic
* tick is used, RTC wakeup counter is used to generate it.
* In tickless mode, SysTick is used to generate tick and RTC is
* used for wakeup from tickless sleep.
*/
void portInitClock(void)
{
#if POSCFG_FEATURE_TICKLESS != 0
/*
* Initialize Systick timer.
*/
SysTick_Config(SystemCoreClock / HZ);
NVIC_SetPriority(SysTick_IRQn, PORT_SYSTICK_PRI);
#endif
/*
* Initialize RTC.
*/
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
PWR_BackupAccessCmd(ENABLE);
RCC_LSEConfig(RCC_LSE_ON);
while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) {
}
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
RCC_RTCCLKCmd(ENABLE);
/*
* RTC_WaitForSynchro has a little bit too small timeout.
* If it return error, just try again (as we don't have any other
* alternatives than working clock).
*/
RTC_BypassShadowCmd(DISABLE);
while (RTC_WaitForSynchro() == ERROR) {
}
RTC_InitTypeDef RTC_InitStructure;
/*
* RTC ticks every sec. Asynch/Synchr dividers
* are set so that we have 1024 resolution in subseconds.
*/
RTC_InitStructure.RTC_AsynchPrediv = 0x1f;
RTC_InitStructure.RTC_SynchPrediv = 0x3ff;
RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
RTC_Init(&RTC_InitStructure);
RTC_TimeTypeDef time;
RTC_DateTypeDef date;
time.RTC_H12 = 0;
time.RTC_Hours = 0;
time.RTC_Minutes = 0;
time.RTC_Seconds = 0;
date.RTC_Date = 1;
date.RTC_Month = 1;
date.RTC_Year = 0;
date.RTC_WeekDay = RTC_Weekday_Saturday; // 1.1.2000: saturday
RTC_SetTime(RTC_Format_BIN, &time);
RTC_SetDate(RTC_Format_BIN, &date);
RTC_BypassShadowCmd(ENABLE);
/*
* Configure Wakup interrupt
*/
EXTI_InitTypeDef EXTI_InitStructure;
EXTI_InitStructure.EXTI_Line = EXTI_Line22;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
NVIC_SetPriority(RTC_WKUP_IRQn, PORT_SYSTICK_PRI);
RTC_WakeUpCmd(DISABLE);
#if POSCFG_FEATURE_TICKLESS == 0
RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div2);
RTC_SetWakeUpCounter(16384 / HZ);
EXTI_ClearITPendingBit(EXTI_Line22);
RTC_ITConfig(RTC_IT_WUT, ENABLE);
RTC_ClearITPendingBit(RTC_IT_WUT);
RTC_ClearFlag(RTC_FLAG_WUTF);
NVIC_EnableIRQ(RTC_WKUP_IRQn);
RTC_WakeUpCmd(ENABLE);
#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)
{
/* 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)
{
}
}
void UB_RTC_SetWakeUpInterrupt(RTC_WAKEUP_t wakeup)
{
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
uint32_t wakeup_time=0x7FF;
if(wakeup==RTC_WAKEUP_STOP) {
// WakeUp-Interrupt abschalten
RTC_WakeUpCmd(DISABLE);
// disable Interrupt
RTC_ITConfig(RTC_IT_WUT, DISABLE);
// NVIC disable
NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = DISABLE;
NVIC_Init(&NVIC_InitStructure);
// ext Interrupt 22 disable
EXTI_ClearITPendingBit(EXTI_Line22);
EXTI_InitStructure.EXTI_Line = EXTI_Line22;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = DISABLE;
EXTI_Init(&EXTI_InitStructure);
}
else {
// WakeUp-Interrupt einschalten
// NVIC init
NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
// ext Interrupt 22 einstellen (fuer WakeUp)
EXTI_ClearITPendingBit(EXTI_Line22);
EXTI_InitStructure.EXTI_Line = EXTI_Line22;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
// zum einstellen muss Wakup disabled sein
RTC_WakeUpCmd(DISABLE);
if(wakeup==RTC_WAKEUP_30s) wakeup_time=0xEFFF;
if(wakeup==RTC_WAKEUP_10s) wakeup_time=0x4FFF;
if(wakeup==RTC_WAKEUP_5s) wakeup_time=0x27FF;
if(wakeup==RTC_WAKEUP_1s) wakeup_time=0x7FF;
if(wakeup==RTC_WAKEUP_500ms) wakeup_time=0x3FF;
if(wakeup==RTC_WAKEUP_250ms) wakeup_time=0x1FF;
if(wakeup==RTC_WAKEUP_125ms) wakeup_time=0xFF;
// Teiler 16 => 32,768kHz:16 => 2048 Hz
RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div16);
// WakeUp Counter einstellen
RTC_SetWakeUpCounter(wakeup_time);
// enable Interrupt
RTC_ITConfig(RTC_IT_WUT, ENABLE);
// enable Wakeup
RTC_WakeUpCmd(ENABLE);
}
}