/**
* @brief This function configures the system to enter Standby mode for
* current consumption measurement purpose.
* STANDBY Mode
* ============
* - Backup SRAM and RTC OFF
* - IWDG and LSI OFF
* - Wakeup using WakeUp Pin (PA.00)
* @param None
* @retval None
*/
void StandbyMode_Measure(void)
{
/* Enable WKUP pin 1 */
PWR_WakeUpPinCmd(ENABLE);
/* Clear Power WakeUp (CWUF) pending 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)
{
}
}
STATIC mp_obj_t pyb_stop(void) {
#if 0
PWR_EnterSTANDBYMode();
//PWR_FlashPowerDownCmd(ENABLE); don't know what the logic is with this
/* Enter Stop Mode */
PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
/* Configures system clock after wake-up from STOP: enable HSE, PLL and select
* PLL as system clock source (HSE and PLL are disabled in STOP mode) */
SYSCLKConfig_STOP();
//PWR_FlashPowerDownCmd(DISABLE);
#endif
return mp_const_none;
}
/* Check whether goto standby
* If PA0==0, goto standby mode.
*
*/
static void check_gotostandby(void)
{
wakeUpIOInit();
if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == Bit_RESET) {
//enable interrupt
EXTI->IMR |= EXTI_Line0;
//stm32 enter standby mode
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
PWR_WakeUpPinCmd(ENABLE);
PWR_EnterSTANDBYMode();
while(1);
} else {
//enable_watchdog(5);
}
}
/**
* @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 Pin2 (PC.13)
* @param None
* @retval None
*/
void StandbyMode_Measure(void)
{
/* Disable wake-up source(Wake up pin) to guarantee free access to WUT level-OR input */
PWR_WakeUpPinCmd(PWR_WakeUpPin_2, DISABLE);
/* Clear Wake-up flag */
PWR_ClearFlag(PWR_FLAG_WU);
PWR_ClearFlag(PWR_FLAG_SB);
/* Enable WKUP pin 1 */
PWR_WakeUpPinCmd(PWR_WakeUpPin_2,ENABLE);
/* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */
PWR_EnterSTANDBYMode();
/* Infinite loop */
while (1)
{
}
}
void HAL_Core_Execute_Standby_Mode(void)
{
/* Should we execute System Standby mode */
if(BKP_ReadBackupRegister(BKP_DR9) == 0xA5A5)
{
/* Clear Standby mode system flag */
BKP_WriteBackupRegister(BKP_DR9, 0xFFFF);
/* Enable WKUP pin */
PWR_WakeUpPinCmd(ENABLE);
/* Request to enter STANDBY mode */
PWR_EnterSTANDBYMode();
/* Following code will not be reached */
while(1);
}
}
/**
* @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)
{
}
}
/**
* @brief This function handles External lines 9 to 5 interrupt request.
* @param None
* @retval None
*/
void EXTI15_10_IRQHandler(void)
{
if(EXTI_GetITStatus(KEY_BUTTON_EXTI_LINE) != RESET)
{
/* Clear the SEL Button EXTI line pending bit */
EXTI_ClearITPendingBit(KEY_BUTTON_EXTI_LINE);
/* Disable the Alarm A */
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
/* Disable RTC Alarm A Interrupt */
RTC_ITConfig(RTC_IT_ALRA, DISABLE);
/* Clear Power WakeUp (CWUF) pending flag */
PWR_ClearFlag(PWR_FLAG_WU);
RTC_GetTime(RTC_Format_BIN, &RTC_TimeStructure);
/* Set the alarm to current time + 5s */
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_TimeStructure.RTC_H12;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = RTC_TimeStructure.RTC_Hours;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = RTC_TimeStructure.RTC_Minutes;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = (RTC_TimeStructure.RTC_Seconds + 0x5) % 60;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay | RTC_AlarmMask_Hours | RTC_AlarmMask_Minutes;
RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure);
/* Enable RTC Alarm A Interrupt: this Interrupt will wake-up the system from
STANDBY mode (RTC Alarm IT not enabled in NVIC) */
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
/* Enable the Alarm A */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
/* Clear RTC Alarm Flag */
RTC_ClearFlag(RTC_FLAG_ALRAF);
/* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */
PWR_EnterSTANDBYMode();
}
}
void EXTI9_5_IRQHandler(void)
#endif
{
if(EXTI_GetITStatus(SEL_BUTTON_EXTI_LINE) != RESET)
{
/* Clear the SEL Button EXTI line pending bit */
EXTI_ClearITPendingBit(SEL_BUTTON_EXTI_LINE);
/* Turn on LED1 */
STM_EVAL_LEDOn(LED1);
/* Disable the Alarm A */
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
RTC_GetTime(RTC_Format_BCD, &RTC_TimeStructure);
/* Set the alarm X+5s */
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_TimeStructure.RTC_H12;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = RTC_TimeStructure.RTC_Hours;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = RTC_TimeStructure.RTC_Minutes;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = (RTC_TimeStructure.RTC_Seconds + 0x5) % 60;
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 A */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
/* Clear RTC Alarm A flag */
RTC_ClearFlag(RTC_FLAG_ALRAF);
/* Clear WakeUp flag */
PWR_ClearFlag(PWR_FLAG_WU);
/* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */
PWR_EnterSTANDBYMode();
}
}
int get_reset_reason( void )
{
int sts = 0;
if( RCC_GetFlagStatus( RCC_FLAG_PINRST ) == SET )
{
sts |= MAIN_RST_FOR_PIN;
}
if( RCC_GetFlagStatus( RCC_FLAG_PORRST ) == SET )
{
sts |= MAIN_RST_FOR_POR;
}
if( RCC_GetFlagStatus( RCC_FLAG_SFTRST ) == SET )
{
sts |= MAIN_RST_FOR_SFT;
}
if( RCC_GetFlagStatus( RCC_FLAG_IWDGRST ) == SET )
{
sts |= MAIN_RST_FOR_IWD;
if( main_is_enter_stby_mode == MAIN_ENTER_STBY_MODE )
{
main_is_enter_stby_mode = 0;
PWR_WakeUpPinCmd( ENABLE );
PWR_EnterSTANDBYMode();
}
}
if( RCC_GetFlagStatus( RCC_FLAG_WWDGRST ) == SET )
{
sts |= MAIN_RST_FOR_WWD;
}
if( RCC_GetFlagStatus( RCC_FLAG_LPWRRST ) == SET )
{
sts |= MAIN_RST_FOR_LPR;
}
RCC_ClearFlag(); // clear all reset flags
return sts;
} // end of get_reset_reason()
static int rtc_standbyUntil( lua_State* L )
{
RTC_AlarmTypeDef RTC_AlarmStructure;
mico_rtos_suspend_all_thread();
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_HourFormat_24;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = luaL_checkinteger( L, 1 );
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = luaL_checkinteger( L, 2 );
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = luaL_checkinteger( L, 3 );
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay ;
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
/* Disable the Alarm A */
RTC_ITConfig(RTC_IT_ALRA, DISABLE);
/* Clear RTC Alarm Flag */
RTC_ClearFlag(RTC_FLAG_ALRAF);
RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure);
/* Enable RTC Alarm A Interrupt: this Interrupt will wake-up the system from
STANDBY mode (RTC Alarm IT not enabled in NVIC) */
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
/* Enable the Alarm A */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
char buff[32];
sprintf(buff,"Wake up at %02d:%02d:%02d\r\n", RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours, RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes, RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds);
l_message(NULL,buff);
PWR_EnterSTANDBYMode();
mico_rtos_resume_all_thread();
lua_pushstring(L, "RETURN FROM STANDBY");
return 1;
}
/**
* @brief This function handles External lines 9 to 5 interrupt request.
* @param None
* @retval None
*/
void EXTI9_5_IRQHandler(void)
{
if(EXTI_GetITStatus(KEY_BUTTON_EXTI_LINE) != RESET)
{
/* Clear the Key Button EXTI line pending bit */
EXTI_ClearITPendingBit(KEY_BUTTON_EXTI_LINE);
/* Turn on LED1 */
STM_EVAL_LEDOn(LED1);
/* Wait till RTC Second event occurs */
RTC_ClearFlag(RTC_FLAG_SEC);
while(RTC_GetFlagStatus(RTC_FLAG_SEC) == RESET);
/* Set the RTC Alarm after 3s */
RTC_SetAlarm(RTC_GetCounter()+ 3);
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
/* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */
PWR_EnterSTANDBYMode();
}
}
void TIM2_IRQHandler(void)
{
if ( TIM_GetITStatus(TIM2 , TIM_IT_Update) != RESET )
{
TIM_ClearITPendingBit(TIM2 , TIM_FLAG_Update);
/////////////////////////////////////////////////////////////////
// Power OFF GPS and GSM before go into standby mode
/////////////////////////////////////////////////////////////////
GSM_TurnOnOff_delay();
#ifdef USE_STM32_GPS_BOARD_VB
GPSPowerOff();
GSM_PowerOff();
#endif
/* Wait till RTC Second event occurs */
RTC_ClearFlag(RTC_FLAG_SEC);
while(RTC_GetFlagStatus(RTC_FLAG_SEC) == RESET);
// normal working state
if(BKP_TRUE == BKP_ReadBackupRegister(BKP_DR1))
{
/* Set the RTC Alarm after xx s */
DEBUG("in timer2 bkptrue %d\n", (BKP_ReadBackupRegister(BKP_DR4) + BKP_ReadBackupRegister(BKP_DR4) <<16));
RTC_SetAlarm(RTC_GetCounter()+ ((BKP_ReadBackupRegister(BKP_DR4) + BKP_ReadBackupRegister(BKP_DR4) <<16)/SLEEP_TIM2_RATIO));
}
else
{
DEBUG("in timer2 bkpfalse\n");
RTC_SetAlarm(RTC_GetCounter()+ (SLEEP_NORMAL_SEC/SLEEP_TIM2_RATIO));
}
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
/* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */
PWR_EnterSTANDBYMode();
}
}
void Platform_Enter_STANDBY(void)
{
PWR_WakeUpPinCmd(ENABLE);
PWR_EnterSTANDBYMode();
}
/*********************************************************************************
*Function : void RTC_Configuration(void)
*Description : RTC config
*Input : none
*Output : none
*Return : none
*author : lz
*date : 6-December-2014
*Others : none
**********************************************************************************/
void RTC_Configuration(void)
{
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
/* Enable write access to Backup domain */
PWR_BackupAccessCmd(ENABLE);
/* Should we execute System Standby mode */
if(BKP_ReadBackupRegister(BKP_DR9) == 0xA5A5)
{
/* Clear Standby mode system flag */
BKP_WriteBackupRegister(BKP_DR9, 0xFFFF);
/* Request to enter STANDBY mode */
PWR_EnterSTANDBYMode();
/* Following code will not be reached */
while(1);
}
EXTI_InitTypeDef EXTI_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
/* Configure EXTI Line17(RTC Alarm) to generate an interrupt on rising edge */
EXTI_ClearITPendingBit(EXTI_Line17);
EXTI_InitStructure.EXTI_Line = EXTI_Line17;
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 Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = RTC_IRQ_PRIORITY; //OLD: 0x01
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x00; //OLD: 0x01
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* Enable the RTC Alarm Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = RTCAlarm_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = RTCALARM_IRQ_PRIORITY; //OLD: 0x01
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x00; //OLD: 0x02
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* Check if the StandBy flag is set */
if(PWR_GetFlagStatus(PWR_FLAG_SB) != RESET)
{
/* System resumed from STANDBY mode */
/* 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 */
/* Enable LSE */
RCC_LSEConfig(RCC_LSE_ON);
/* Wait till LSE is ready */
while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
{
//Do nothing
}
/* Select LSE as RTC Clock Source */
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
/* Enable RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC registers synchronization */
RTC_WaitForSynchro();
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
/* Set RTC prescaler: set RTC period to 1sec */
RTC_SetPrescaler(32767); /* RTC period = RTCCLK/RTC_PR = (32.768 KHz)/(32767+1) */
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
}
/* Enable the RTC Second and RTC Alarm interrupt */
RTC_ITConfig(RTC_IT_SEC | RTC_IT_ALR, ENABLE);
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
}
/*******************************************************************************
* Function Name : NMI_Handler
* Description : This function handles NMI exception.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void NMI_Handler(void)
{
uint32_t tmp = 318, index = 0;
/* Disable LCD Window mode */
LCD_WindowModeDisable();
/* If HSE is not detected at program startup or HSE clock failed during program execution */
if((Get_HSEStartUpStatus() == ERROR) || (RCC_GetITStatus(RCC_IT_CSS) != RESET))
{
/* Clear the LCD */
LCD_Clear(White);
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
/* Set the LCD Text Color */
LCD_SetTextColor(White);
/* Display " No Clock Detected " message */
LCD_DisplayStringLine(Line0, "No HSE Clock ");
LCD_DisplayStringLine(Line1, "Detected. STANDBY ");
LCD_DisplayStringLine(Line2, "mode in few seconds. ");
LCD_DisplayStringLine(Line5, "If HSE Clock ");
LCD_DisplayStringLine(Line6, "recovers before the ");
LCD_DisplayStringLine(Line7, "time out, a System ");
LCD_DisplayStringLine(Line8, "Reset is generated. ");
LCD_ClearLine(Line9);
/* Clear Clock Security System interrupt pending bit */
RCC_ClearITPendingBit(RCC_IT_CSS);
GPIO_SetBits(GPIOC, GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9);
/* Enable HSE */
RCC_HSEConfig(RCC_HSE_ON);
LCD_ClearLine(Line4);
/* Set the Back Color */
LCD_SetBackColor(White);
/* Set the Text Color */
LCD_SetTextColor(Red);
LCD_DrawRect(71, 319, 25, 320);
LCD_SetBackColor(Green);
LCD_SetTextColor(White);
/* Wait till HSE is ready */
while(RCC_GetFlagStatus(RCC_FLAG_HSERDY) == RESET)
{
if(index == 0x3FFFF)
{
LCD_DisplayChar(Line3, tmp, 0x20);
tmp -= 16;
index = 0;
}
index++;
/* Enters the system in STANDBY mode */
if(tmp < 16)
{
LCD_SetBackColor(Blue);
LCD_ClearLine(Line3);
LCD_ClearLine(Line4);
LCD_ClearLine(Line5);
LCD_ClearLine(Line6);
LCD_DisplayStringLine(Line7, " MCU in STANDBY Mode");
LCD_DisplayStringLine(Line8, "To exit press Wakeup");
/* Request to enter STANDBY mode */
PWR_EnterSTANDBYMode();
}
}
/* Generate a system reset */
NVIC_SystemReset();
}
}
void Board_main(void)
{
uint8_t i;
uint16_t flash_flag = 0;
uint16_t copy_file_flag = 0;
/* 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)
{
#if 0
/* Enable Prefetch Buffer */
FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
FLASH_HalfCycleAccessCmd(FLASH_HalfCycleAccess_Disable);
/* Flash 2 wait state */
FLASH_SetLatency(FLASH_Latency_2);
#else
FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
FLASH_HalfCycleAccessCmd(FLASH_HalfCycleAccess_Enable);
/* Flash 2 wait state */
/*FLASH_SetLatency(FLASH_Latency_2);*/
FLASH_SetLatency(FLASH_Latency_0); /*abin@ */
#endif
/* HCLK = SYSCLK */
RCC_HCLKConfig(RCC_SYSCLK_Div1);
/* PCLK2 = HCLK */
RCC_PCLK2Config(RCC_HCLK_Div1);
/* PCLK1 = HCLK/2 */
RCC_PCLK1Config(RCC_HCLK_Div2);
#if 0
/* PLLCLK = 8MHz * 9 = 72 MHz */
/*abin:note*/
RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
// RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_8);
/* Enable PLL */
RCC_PLLCmd(ENABLE);
/* Wait till PLL is ready */
while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
{
}
/* Select PLL as system clock source */
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
/* Wait till PLL is used as system clock source */
while(RCC_GetSYSCLKSource() != 0x08)
{
}
#else
RCC_PLLCmd(DISABLE);
/* Select HSE as system clock source */
RCC_SYSCLKConfig(RCC_SYSCLKSource_HSE);
/* Wait till PLL is used as system clock source */
while(RCC_GetSYSCLKSource() != 0x04)
{
}
#endif
}
/* Enable GPIOA, GPIOB, and AFIO clocks */
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA |RCC_APB2Periph_GPIOB| RCC_APB2Periph_AFIO, ENABLE);
/* Enable DMA1 ,DMA2 clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1|RCC_AHBPeriph_DMA2, ENABLE);
/* Enable ADC1 ADC2,and GPIOC clock */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 |RCC_APB2Periph_ADC2| RCC_APB2Periph_GPIOC, ENABLE);
/* Enable PWR and BKP clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
/* Enable write access to Backup domain */
PWR_BackupAccessCmd(ENABLE);
/* Clear Tamper pin Event(TE) pending flag */
BKP_ClearFlag();
#if ABIN_DEBUG
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
STM_EVAL_COMInit(COM1, &USART_InitStructure);
/* Output a message on Hyperterminal using printf function */
//sys_printf("\n\r abin 8M is ok moify flash latency :USART Init end \n\r");
#endif
/*------------------- Resources Initialization -----------------------------*/
/* GPIO Configuration */
GPIO_Config();
//sys_printf("\n\r abin mul2 :GPIO_Config \n\r");
#if ABIN_CPU_UPGRADE2HIGHSPEED_OPTION
USB_Plugin_State = GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_14);
if(USB_Plugin_State == 1)
{
//sys_printf("\n\r abin switch to high speed !!\n\r");
UpgradeToHighSpeed();
}
#endif
/* Interrupt Configuration */
InterruptConfig();
/* Configure the systick */
SysTick_Configuration();
/*------------------- Drivers Initialization -------------------------------*/
/* Initialize the Low Power application */
LowPower_Init();
/* Enable WKUP pin */
PWR_WakeUpPinCmd(ENABLE);
/* Allow access to BKP Domain */
PWR_BackupAccessCmd(ENABLE);
RTC_Init();
/* If HSE is not detected at program startup */
if(HSEStartUpStatus == ERROR)
{
/* Generate NMI exception */
SCB->ICSR |= SCB_ICSR_NMIPENDSET;
}
USB_Disconnect_Config();
GPIO_SetBits(USB_DISCONNECT, USB_DISCONNECT_PIN);/*???abin@20100714*/
WakupPin_Init();
//sys_printf("\n\r abin before CheckPowerOnReason\n\r");
CheckPowerOnReason();
//sys_printf("\n\r abin after CheckPowerOnReason\n\r");
Board_ADC_Init();
/*init the flag*/
flash_flag = *(uint16_t *)FLASH_READY_ADDRESS;
if( flash_flag != FLAG_FLASH_READY)
{
//sys_printf("\n\r abin ready to erase flash \n\r");
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
//Erase the 32 page 32K
for(i = 0;i< DATA_PAGES;i++)
{
//sys_printf("\n\r abin ready to erase aa");
FLASH_ErasePage(DATA_LOGGER_ADDRESS_START + i * 1024);/*数据在Page1...page32存放*/
}
FLASH_ErasePage(FLASH_READY_ADDRESS); /*abin@20100715 没添加保护*/
FLASH_ProgramHalfWord(FLASH_READY_ADDRESS , FLAG_FLASH_READY);
FLASH_ErasePage(REOCRD_COUNT_ADDRESS);
FLASH_ProgramHalfWord(REOCRD_COUNT_ADDRESS , 0x0000);
FLASH_Lock();
//sys_printf("\n\r abin mul2 :erase flash end!!!\n\r");
}
//sys_printf("\n\r abin ready to erase flash end \n\r");
USB_Plugin_State = GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_14);
if(USB_Plugin_State == 0)
{
record_count = *(uint16_t *)REOCRD_COUNT_ADDRESS;
if(record_count >= 15428)
{
//Write the full flag
//Do nothing....
while(1)
{
//sys_printf("\n\r sample end !!!!!!!!!!!!!!!!!!!!!\n\r");
Led_One_By_One(4);
/*应该进入standy 模式 abin@20100715*/
}
}
else
{
//sys_printf("\n\r abin ready to add sample count \n\r");
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
FLASH_ProgramHalfWord(DATA_LOGGER_ADDRESS_START + record_count * 2, GetTemperature());
//Erase first
FLASH_ErasePage(REOCRD_COUNT_ADDRESS);
//Update the count
record_count = record_count + 1;
FLASH_ProgramHalfWord(REOCRD_COUNT_ADDRESS , record_count);
FLASH_Lock();
//sys_printf("\n\r abin add sample count :end\n\r");
}
//sys_printf("\n\r %000\n\r");
GPIO_SetBits(GPIOA, GPIO_Pin_1);
#if 0
Delay(25);
#else
Delay(5);
#endif
//sys_printf("\n\r %111\n\r");
}
else
{
Enable_SDcard();
/*
if there is usb connect, copy the data to sdcard. and start the mass storage
*/
copy_file_flag = *(uint16_t *)COPY_FILE_ADDRESS;
if(copy_file_flag == FLAG_FILE_COPYED)
{
Write_Copy_File_Flag(FLAG_FILE_NO_COPYED);
USB_Disconnect_Config();
GPIO_SetBits(USB_DISCONNECT, USB_DISCONNECT_PIN);
Delay(10);
GPIO_ResetBits(USB_DISCONNECT, USB_DISCONNECT_PIN);
/* Enable and GPIOD clock */
Mass_Storage_Start ();
while( bDeviceState != CONFIGURED)
{
Led_Both(1);
}
USB_Plugin_State = GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_14);
while( USB_Plugin_State == 1)/* U-DISK success ,then CPU Loop in here*/
{
USB_Plugin_State = GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_14);
Led_One_By_One(1);
//sys_printf("\n\r abin :mul2 u disk !!!\n\r");
}
PowerOff();
Write_Copy_File_Flag(FLAG_FILE_NO_COPYED);
}
else
{
Write_Copy_File_Flag(FLAG_FILE_COPYED);
Led_Green_Flink(3);
NAND_FAT();
CreateDataLoggerFile();
Write_Copy_File_Flag(FLAG_FILE_COPYED);
//sys_printf("\n\r abin :mul2 NAND_FAT!!!\n\r");
}
//sys_printf("\n\r abin :mul2 Disable_SDcard!!!\n\r");
Disable_SDcard();
BKP_WriteBackupRegister(BKP_POWER_ON, FLAG_POWER_OFF);
PWR_EnterSTANDBYMode();
/* Generate a system reset */
//NVIC_SystemReset();
}
//sys_printf("\n\r @111 \n\r");
/* Set the RTC Alarm after 60s */
RTC_SetAlarm(RTC_GetCounter()+ 3);
//sys_printf("\n\r @222:RTC_GetCounter()=0x%x \n\r",RTC_GetCounter());
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
//sys_printf("\n\r @333\n\r");
PWR_EnterSTANDBYMode();
}
void CheckPowerOnReason()
{
#if 0
while(1)
{
Led_Both(4);
}
#endif
/*If there is usb connected, just return.*/
USB_Plugin_State = GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_14);
if(USB_Plugin_State == 1)
{
//sys_printf("\n\r CheckPowerOnReason :USB_Plugin_State == 1!!!\n\r");
Delay(15);
USB_Plugin_State = GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_14);
if(USB_Plugin_State == 1)
{
/* usb wake up*/
BKP_WriteBackupRegister(BKP_POWER_ON, FLAG_POWER_ON);
//sys_printf("\n\r CheckPowerOnReason :USB_Plugin_State == 1 ret\n\r");
return ;
}
}
/* Check if the Power On Reset flag is set */
if (RCC_GetFlagStatus(RCC_FLAG_PORRST) != RESET)
{
//sys_printf("\n\r CheckPowerOnReason :!= RESET \n\r");
/*First time power on .*/
GPIO_SetBits(GPIOA, GPIO_Pin_1);
GPIO_SetBits(GPIOA, GPIO_Pin_2);
//sys_printf("\n\r CheckPowerOnReason :!= RESET bef delay 200 \n\r");
Delay(50 * 4);
//sys_printf("\n\r CheckPowerOnReason :!= RESET after 200 \n\r");
BKP_WriteBackupRegister(BKP_POWER_ON, FLAG_POWER_OFF);
RCC_ClearFlag();
//sys_printf("\n\r CheckPowerOnReason :!= RESET standy \n\r");
/* power off standby*/
PWR_EnterSTANDBYMode();
}
else
{
if (WaitWakeupPin() == 1) //user press the pin for 3 seconds.....
{
if(FLAG_POWER_ON == BKP_ReadBackupRegister(BKP_POWER_ON))
{
//sys_printf("\n\r CheckPowerOnReason :Power off,enter standby mode \n\r");
//Power off
BKP_WriteBackupRegister(BKP_POWER_ON, FLAG_POWER_OFF);
Led_Power_Off();
PWR_EnterSTANDBYMode();
}
else
{
//sys_printf("\n\r CheckPowerOnReason :Power on\n\r");
//Power on
BKP_WriteBackupRegister(BKP_POWER_ON, FLAG_POWER_ON);
Led_Power_On();
}
}
else
{
if(FLAG_POWER_ON == BKP_ReadBackupRegister(BKP_POWER_ON))
{
// PLUG OUT USB ,then press Wake up key will call this code
//sys_printf("\n\r CheckPowerOnReason :FLAG_POWER_ON == BKP_ReadBackupRegister(BKP_POWER_ON)\n\r");
//power on with rtc or wake up pin -- need to data logger
BKP_WriteBackupRegister(BKP_POWER_ON, FLAG_POWER_ON);
}
else
{
//sys_printf("\n\r CheckPowerOnReason :write FLAG_POWER_OFF, enter standyby \n\r");
BKP_WriteBackupRegister(BKP_POWER_ON, FLAG_POWER_OFF);
//continue to power off mode.
PWR_EnterSTANDBYMode();
}
}
}
}
void Sys_Standby(void)
{
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); //使能PWR外设时钟
PWR_WakeUpPinCmd(ENABLE); //使能唤醒管脚功能
PWR_EnterSTANDBYMode(); //进入待命（STANDBY）模式
}
STATIC mp_obj_t pyb_standby(void) {
#if 0
PWR_EnterSTANDBYMode();
#endif
return mp_const_none;
}
//====================================
static int rtc_standby( lua_State* L )
{
char buff[60];
uint8_t mode = luaL_checkinteger( L, 1 );
if (mode > 1) {
l_message( NULL, "mode has to be 0 or 1" );
return 0;
}
if (mode==1 && use_wwdg == 0) {
l_message(NULL,"IWDG active, cannot enter STOP mode.");
return 0;
}
int nsec = luaL_checkinteger( L, 2 );
if ((nsec < 1) || (nsec > 84559)) {
l_message(NULL,"wrong interval (1~84599)");
return 0;
}
TM_RTC_DisableAlarm(TM_RTC_Alarm_A);
TM_RTC_DisableAlarm(TM_RTC_Alarm_B);
platform_rtc_time_t time;
uint32_t currentSecond;
RTC_AlarmTypeDef RTC_AlarmStructure;
platform_rtc_get_time(&time);
currentSecond = time.hr*3600 + time.min*60 + time.sec;
currentSecond += nsec;
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_HourFormat_24;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = currentSecond/3600%24;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = currentSecond/60%60;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = currentSecond%60;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay ;
RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure);
// Enable RTC Alarm A Interrupt
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
// Enable the Alarm A
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
/* Clear Alarm A pending bit */
/* Clear RTC Alarm Flag */
RTC_ClearFlag(RTC_FLAG_ALRAF);
RTC_ClearFlag(RTC_IT_ALRA);
if (mode == 0) sprintf(buff,"Going to STANDBY MODE...\r\n");
else if (mode == 1) sprintf(buff,"Going to STOP MODE...\r\n");
l_message(NULL,buff);
sprintf(buff,"Wake up in %d second(s)\r\n", nsec);
l_message(NULL,buff);
//mico_rtos_suspend_all_thread();
if (mode == 0) {
PWR_EnterSTANDBYMode();
// RESET
}
else if (mode == 1) {
PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
// restore clocks
init_clocks();
}
//mico_rtos_resume_all_thread();
// *** Back from stop ***
TM_RTC_DisableAlarm(TM_RTC_Alarm_A);
TM_RTC_DisableAlarm(TM_RTC_Alarm_B);
luaWdgReload();
l_message(NULL,"Back from power save mode.");
return 0;
}
int main(void)
{
UINT n = 0;
GPIO_InitTypeDef GPIO_InitStructure;
/* FF用のPB14の設定 */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* RWD用のPB13の設定 */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* HOLD用のPB12の設定 */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* FN1242 DAC コントロール用のPC4-6の設定 */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 |GPIO_Pin_5 |GPIO_Pin_6;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIO_ResetBits(GPIOC,GPIO_Pin_4 | GPIO_Pin_5); // MC <= 0 MD <= 0
GPIO_SetBits(GPIOC,GPIO_Pin_6); // ML <= 1
#ifdef USE_USART
conio_init(UART_DEFAULT_NUM,UART_BAUDLATE);
#ifdef USE_PRINTF
printf("\n");
printf("Welcome to %s test program !!\n",MPU_SUBMODEL);
printf("Version %s!!\n",APP_VERSION);
printf("Build Date : %s\n",__DATE__);
#else
cputs("\r\n");
cputs("Welcome to");
cputs(MPU_SUBMODEL);
cputs("test program !!\r\n");
cputs("Version");
cputs(APP_VERSION);
cputs("!!\r\n");
cputs("Build Date : ");
cputs(__DATE__);
cputs("\r\n");
#endif
#endif
/* ADCの初期化 */
initADC();
/* I2Sポートの初期化*/
initI2S();
/* I2Sポートをスタート */
startI2S(44100,16);
/* IRQの設定とDMAのイネーブル */
setIRQandDMA();
if ((!initSD()) && (lsSD() == FR_OK)) {
while (Command_index != 3) {
sdio_playNO(n);
if ((Command_index == 0) || (Command_index == 1)) {
n++;
if (n >= sMUSIC) {
n = 0;
}
} else if (Command_index == 2){
if (n == 0) {
if (sMUSIC > 0) {
n = sMUSIC - 1;
} else {
n = 0;
}
} else {
n--;
}
}
}
}
while(1) {
}
#ifndef NO_ADC
#ifdef USE_PRINTF
printf("Low Voltage Stop\n");
#endif
PWR_EnterSTANDBYMode();
#endif
while(1) {
}
}
void shutdown() {
PWR_WakeUpPinCmd(ENABLE); //enable the pin
PWR_EnterSTANDBYMode(); //only wakes on RTC signals or WKUP pin
}
/**
* @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();
}
//=========================================
static int rtc_standbyUntil( lua_State* L )
{
uint8_t h,m,s;
RTC_AlarmTypeDef RTC_AlarmStructure;
char buff[64];
uint8_t mode = luaL_checkinteger( L, 1 );
if (mode > 1) {
l_message( NULL, "mode has to be 0 or 1" );
return 0;
}
if (mode==1 && use_wwdg == 0) {
l_message(NULL,"IWDG active, cannot enter STOP mode.");
return 0;
}
if (!lua_istable(L, 2)) {
l_message( NULL, "table arg needed" );
return 0;
}
if (lua_objlen( L, 2 ) != 3) {
l_message( NULL, "hour,minute,second expected" );
return 0;
}
lua_rawgeti( L, 2, 1 );
h = ( int )luaL_checkinteger( L, -1 );
lua_pop( L, 1 );
lua_rawgeti( L, 2, 2 );
m = ( int )luaL_checkinteger( L, -1 );
lua_pop( L, 1 );
lua_rawgeti( L, 2, 3 );
s = ( int )luaL_checkinteger( L, -1 );
lua_pop( L, 1 );
TM_RTC_DisableAlarm(TM_RTC_Alarm_A);
TM_RTC_DisableAlarm(TM_RTC_Alarm_B);
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_HourFormat_24;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = h;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = m;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = s;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay ;
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
/* Disable the Alarm A */
RTC_ITConfig(RTC_IT_ALRA, DISABLE);
/* Clear RTC Alarm Flag */
RTC_ClearFlag(RTC_FLAG_ALRAF);
RTC_ClearFlag(RTC_IT_ALRA);
RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure);
/* Enable RTC Alarm A Interrupt: this Interrupt will wake-up the system from
STANDBY mode (RTC Alarm IT not enabled in NVIC) */
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
/* Enable the Alarm A */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
if (mode == 0) sprintf(buff,"Going to STANDBY MODE...\r\n");
else if (mode == 1) sprintf(buff,"Going to STOP MODE...\r\n");
l_message(NULL,buff);
sprintf(buff,"Wake up at %02d:%02d:%02d\r\n", RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours, RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes, RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds);
l_message(NULL,buff);
//mico_rtos_suspend_all_thread();
if (mode == 0) {
PWR_EnterSTANDBYMode();
}
else if (mode == 1) {
PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
init_clocks();
}
//mico_rtos_resume_all_thread();
// *** Back from stop ***
TM_RTC_DisableAlarm(TM_RTC_Alarm_A);
TM_RTC_DisableAlarm(TM_RTC_Alarm_B);
luaWdgReload();
l_message(NULL,"Back from power save mode.");
return 0;
}
/**
* @brief Enter the MCU selected low power modes.
* @param lpmode: selected MCU low power modes. This parameter can be one of the
* following values:
* @arg STM32L_RUN: Run mode at 32MHz.
* @arg STM32L_RUN_1M: Run mode at 1MHz.
* @arg STM32L_RUN_LP: Low power Run mode at 32KHz.
* @arg STM32L_SLEEP: Sleep mode at 16MHz.
* @arg STM32L_SLEEP_LP: Low power Sleep mode at 32KHz.
* @arg STM32L_STOP: Stop mode with or without RTC.
* @arg STM32L_STANDBY: Standby mode with or without RTC.
* @param RTCState: RTC peripheral state during low power modes. This parameter
* is valid only for STM32L_RUN_LP, STM32L_SLEEP_LP, STM32L_STOP and
* STM32L_STANDBY. This parameter can be one of the following values:
* @arg RTC_STATE_ON: RTC peripheral is ON during low power modes.
* @arg RTC_STATE_OFF: RTC peripheral is OFF during low power modes.
* @param CalibrationState: Bias Calibration mode selection state during low
* power modes.
* This parameter can be one of the following values:
* @arg BIAS_CALIB_OFF: Bias Calibration mode is selected during
* low power modes.
* @arg BIAS_CALIB_ON: Bias Calibration mode isn't selected during
* low power modes.
* @retval None
*/
void IDD_Measurement(uint32_t lpmode, uint8_t RTCState, uint8_t CalibrationState)
{
GPIO_InitTypeDef GPIO_InitStructure;
uint16_t mode = STM32L_MODE_LP, adcdata, i;
/* Disable the Wakeup Interrupt */
RTC_ITConfig(RTC_IT_WUT, DISABLE);
/* Disable the JoyStick interrupts */
Demo_IntExtOnOffConfig(DISABLE);
/* Disable Leds toggling */
Demo_LedShow(DISABLE);
/* Save the RCC configuration */
RCC_AHBENR = RCC->AHBENR;
RCC_APB2ENR = RCC->APB2ENR;
RCC_APB1ENR = RCC->APB1ENR;
/* Disable PVD */
PWR_PVDCmd(DISABLE);
/* Wait until JoyStick is pressed */
while (Menu_ReadKey() != NOKEY)
{}
/* Save the GPIO pins current configuration then put all GPIO pins in Analog
Input mode ...*/
IDD_Measurement_SaveContext();
/* Clear Wake Up flag */
PWR_ClearFlag(PWR_FLAG_WU);
RCC->AHBENR = 0x05;
RCC->APB2ENR = 0x00;
RCC->APB1ENR = 0x10000000; /* PWR APB1 Clock enable */
switch(lpmode)
{
/*=========================================================================*
* RUN MODE 32MHz (HSE + PLL) *
*========================================================================*/
case STM32L_RUN:
{
mode = STM32L_MODE_RUN;
/* Needed delay to have a correct value on capacitor C25.
Running NOP during waiting loop will decrease the current consumption. */
for (i = 0;i < 0xFFFF; i++)
{
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
}
}
break;
/*=========================================================================*
* RUN MODE MSI 1MHz *
*========================================================================*/
case STM32L_RUN_1M:
{
mode = STM32L_MODE_RUN;
/* Reconfigure the System Clock at MSI 1 MHz */
SetHCLKToMSI_1MHz();
/* Needed delay to have a correct value on capacitor C25.
Running NOP during waiting loop will decrease the current consumption. */
for (i = 0;i < 0x3FFF; i++)
{
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
}
}
break;
/*=========================================================================*
* RUN LOW POWER MODE MSI 32KHz *
*========================================================================*/
case STM32L_RUN_LP:
{
if(!RTCState)
{
RCC_LSEConfig(RCC_LSE_OFF);
}
else
{
if (RTC_GetFlagStatus(RTC_FLAG_INITS) == RESET)
{
/* RTC Configuration ************************************************/
/* 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);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
}
}
/* Configure the System Clock at MSI 32 KHz */
SetHCLKToMSI_64KHz();
RCC_HCLKConfig(RCC_SYSCLK_Div2);
/* Clear IDD_CNT_EN pin */
GPIO_ResetBits(IDD_CNT_EN_GPIO_PORT, IDD_CNT_EN_PIN);
/* Enter low power run mode */
PWR_EnterLowPowerRunMode(ENABLE);
/* Waiting wake-up interrupt */
/* Needed delay to have a correct value on capacitor C25.
Running NOP during waiting loop will decrease the current consumption. */
do
{
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
}while(LowPowerStatus == 0x00);
/* Exit low power run mode before setting the clock to 32MHz */
PWR_EnterLowPowerRunMode(DISABLE);
while(PWR_GetFlagStatus(PWR_FLAG_REGLP) != RESET)
{
}
}
break;
/*=========================================================================*
* SLEEP MODE HSI 16MHz *
*========================================================================*/
case STM32L_SLEEP:
{
mode = STM32L_MODE_RUN;
/* Enable Ultra low power mode */
PWR_UltraLowPowerCmd(ENABLE);
/* Diable FLASH during SLeep LP */
FLASH_SLEEPPowerDownCmd(ENABLE);
RCC_APB2PeriphClockLPModeCmd(RCC_APB2Periph_CLOCK, ENABLE);
RCC_APB1PeriphClockLPModeCmd(RCC_APB1Periph_CLOCK, ENABLE);
RCC_AHBPeriphClockLPModeCmd(RCC_AHBPeriph_CLOCK, ENABLE);
/* Configure the System Clock to 16MHz */
SetHCLKToHSI();
Demo_SysTickConfig();
Demo_Delay(5);
/* Request to enter SLEEP mode with regulator on */
PWR_EnterSleepMode(PWR_Regulator_ON, PWR_STOPEntry_WFI);
}
break;
/*=========================================================================*
* SLEEP LOW POWER MODE MSI 32KHz *
*========================================================================*/
case STM32L_SLEEP_LP:
{
if(!RTCState)
{
RCC_LSEConfig(RCC_LSE_OFF);
}
else
{
if (RTC_GetFlagStatus(RTC_FLAG_INITS) == RESET)
{
/* RTC Configuration ************************************************/
/* 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);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
}
}
/* Enable Ultra low power mode */
PWR_UltraLowPowerCmd(ENABLE);
/* Diable FLASH during SLeep LP */
FLASH_SLEEPPowerDownCmd(ENABLE);
/* Disable HSI clock before entering Sleep LP mode */
RCC_HSICmd(DISABLE);
/* Disable HSE clock */
RCC_HSEConfig(RCC_HSE_OFF);
/* Disable LSI clock */
RCC_LSICmd(DISABLE);
RCC_APB2PeriphClockLPModeCmd(RCC_APB2Periph_CLOCK, ENABLE);
RCC_APB1PeriphClockLPModeCmd(RCC_APB1Periph_CLOCK, ENABLE);
RCC_AHBPeriphClockLPModeCmd(RCC_AHBPeriph_CLOCK, ENABLE);
/* Clear IDD_CNT_EN pin */
GPIO_ResetBits(IDD_CNT_EN_GPIO_PORT, IDD_CNT_EN_PIN);
/* Reconfigure the System Clock at MSI 64 KHz */
SetHCLKToMSI_64KHz();
RCC_HCLKConfig(RCC_SYSCLK_Div2);
/* Request to enter SLEEP mode with regulator low power */
PWR_EnterSleepMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
}
break;
/*=========================================================================*
* STOP LOW POWER MODE *
*========================================================================*/
case STM32L_STOP:
{
/* Enable Ultra low power mode */
PWR_UltraLowPowerCmd(ENABLE);
if(!RTCState)
{
RCC_LSEConfig(RCC_LSE_OFF);
}
else
{
if (RTC_GetFlagStatus(RTC_FLAG_INITS) == RESET)
{
/* RTC Configuration ************************************************/
/* 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);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
}
}
/* Clear IDD_CNT_EN pin */
GPIO_ResetBits(IDD_CNT_EN_GPIO_PORT, IDD_CNT_EN_PIN);
/* Request to enter STOP mode with regulator in low power */
PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
/* Reset the counter by programming IDD_CNT_EN High in less than 70ms after
the wakeup to avoid 1Kohm to be connected later on VDD_MCU */
GPIO_SetBits(IDD_CNT_EN_GPIO_PORT, IDD_CNT_EN_PIN);
/* Configures system clock after wake-up from STOP: enable HSE, PLL and select PLL
as system clock source (HSE and PLL are disabled in STOP mode) */
IDD_Measurement_SYSCLKConfig_STOP();
}
break;
/*=========================================================================*
* STANDBY LOW POWER MODE *
*========================================================================*/
case STM32L_STANDBY:
{
if (RTC_GetFlagStatus(RTC_FLAG_INITS) == RESET)
{
/* RTC Configuration **************************************************/
/* 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);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
}
RTC_OutputTypeConfig(RTC_OutputType_PushPull);
RTC_OutputConfig(RTC_Output_WakeUp, RTC_OutputPolarity_High);
/* To configure PC13 WakeUP output */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_400KHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource13, GPIO_AF_RTC_AF1);
PWR_WakeUpPinCmd(PWR_WakeUpPin_1, ENABLE);
PWR_UltraLowPowerCmd(ENABLE);
RTC_ClearFlag(RTC_FLAG_WUTF | RTC_FLAG_ALRBF | RTC_FLAG_ALRAF | RTC_FLAG_TAMP1F | RTC_FLAG_TSF);
RTC_ITConfig(RTC_IT_WUT, DISABLE);
if(!RTCState)
{
RCC_LSEConfig(RCC_LSE_OFF);
}
/* Clear Wake Up flag */
PWR_ClearFlag(PWR_FLAG_WU);
/* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */
PWR_EnterSTANDBYMode();
}
break;
}
/* Configure the System Clock to 32MHz */
SetHCLKTo32();
/* Reset lowpower status variable*/
LowPowerStatus = 0x00;
RCC->AHBENR = RCC_AHBENR;
RCC->APB2ENR = RCC_APB2ENR;
RCC->APB1ENR = RCC_APB1ENR;
/* Reset the counter by programming IDD_CNT_EN High in less than 70ms after
the wakeup to avoid 1Kohm to be connected later on VDD_MCU */
GPIO_SetBits(IDD_CNT_EN_GPIO_PORT, IDD_CNT_EN_PIN);
/* Measure the Voltage using the ADC */
adcdata = IDD_Measurement_ADC_ReadValue();
/* Write the ADC converted value in the DATA EEPROM memory for Bias Measurement */
if(CalibrationState == BIAS_CALIB_ON)
{
/* Unlock EEPROM write access*/
DATA_EEPROM_Unlock();
/* Store the value in EEPROM for application needs */
DATA_EEPROM_ProgramHalfWord(DATA_EEPROM_BIAS_ADDR, adcdata);
/* Lock back EEPROM write access */
DATA_EEPROM_Lock();
}
IDD_Measurement_ADC_DisplayValue(adcdata, mode);
/* Clear Wake Up flag */
PWR_ClearFlag(PWR_FLAG_WU);
/* Enable PVD */
PWR_PVDCmd(ENABLE);
/* Restore Demonstration Context. */
IDD_Measurement_RestoreContext();
LCD_SetBackColor(LCD_COLOR_GREEN);
LCD_DisplayStringLine(LCD_LINE_6, "STM32L LowPower Mode");
LCD_DisplayStringLine(LCD_LINE_7, Str);
LCD_DisplayStringLine(LCD_LINE_8, "Press JoyStick to ");
LCD_DisplayStringLine(LCD_LINE_9, "continue. ");
/* Wait until Joystick pressed. */
while (Menu_ReadKey() == NOKEY)
{}
/* Disable ADC1 */
ADC_Cmd(ADC1, DISABLE);
LCD_Clear(LCD_COLOR_WHITE);
LCD_GLASS_DisplayString(" STM32L ");
/* Enable the Wakeup Interrupt */
RTC_ITConfig(RTC_IT_WUT, ENABLE);
/* Enable the JoyStick interrupts */
Demo_IntExtOnOffConfig(ENABLE);
/* Display the previous menu */
Menu_DisplayMenu();
}
/**
* @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 Current measurement in different MCU modes:
* RUN/SLEEP/LowPower/STANDBY with/without RTC
* @caller main and ADC_Icc_Test
* @param MCU state
* @retval ADC value.
*/
uint16_t ADC_Icc_Test(uint8_t Mcu_State)
{
GPIO_InitTypeDef GPIO_InitStructure;
uint16_t adc_measure;
uint32_t i;
RCC_TypeDef SavRCC;
/* Reset UserButton State */
UserButton = FALSE;
/* Start counter */
GPIO_HIGH(CTN_GPIO_PORT,CTN_CNTEN_GPIO_PIN);
/* Disable the RTC Wakeup Interrupt */
RTC_ITConfig(RTC_IT_WUT, DISABLE);
/* Disable LCD */
LCD_Cmd(DISABLE);
/* wait until LCD disable */
while (LCD_GetFlagStatus(LCD_FLAG_ENS) == SET);
/*Reset Idd-WakeUP flag*/
Idd_WakeUP = FALSE;
/* Set IO in lowpower configuration*/
GPIO_LowPower_Config();
/*Disable fast wakeUp*/
PWR_FastWakeUpCmd(DISABLE);
/* Test MCU state for configuration */
switch (Mcu_State)
{
/* Run mode : Measurement Measurement performed with MSI 4 MHz without RTC*/
case MCU_RUN:
/* switch on MSI clock */
SetHSICLKToMSI(RCC_MSIRange_6,NoDIV2,NoRTC) ;
/* shitch on MSI clock */
Config_RCC(&SavRCC);
SysTick->CTRL = 0;
RCC->APB1ENR = 0;
/* To run nops during measurement:
it's the best case for low current */
for (i=0;i<0xffff;i++) {
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
}
break;
/* SLEEP mode : Measurement performed with MSI 4 MHz without RTC in WFI mode*/
case MCU_SLEEP:
SetHSICLKToMSI(RCC_MSIRange_6,NoDIV2,NoRTC) ;
Config_RCC(&SavRCC);
Config_Systick_50ms();
Delay(1);
/* Request Wait For Interrupt */
PWR_EnterSleepMode(PWR_Regulator_ON,PWR_SLEEPEntry_WFI);
break;
/* RUN LOW POWER mode : Measurement performed with MSI 32 Khz without RTC */
case MCU_LP_RUN:
/* Disable PVD */
PWR_PVDCmd(DISABLE);
/* Enable The ultra Low Power Mode */
PWR_UltraLowPowerCmd(ENABLE);
/* Save the RCC configuration registers */
Config_RCC(&SavRCC);
/* Stop the sys tick in order to avoid IT */
SysTick->CTRL = 0;
#ifdef TESTINRAM
SetHSICLKToMSI(RCC_MSIRange_0,DIV2,NoRTC) ;
PWR_EnterLowPowerRunMode(ENABLE);
while(PWR_GetFlagStatus(PWR_FLAG_REGLP) == RESET) ;
DisableInterrupts();
EnterLPRUNModeRAM();
EnableInterrupts();
#else
/* Swith in MSI 32KHz */
SetHSICLKToMSI(RCC_MSIRange_64KHz,DIV2,NoRTC) ;
PWR_EnterLowPowerRunMode(ENABLE);
while(PWR_GetFlagStatus(PWR_FLAG_REGLP) == RESET) ;
/* Launch the counter */
GPIO_LOW(CTN_GPIO_PORT,CTN_CNTEN_GPIO_PIN);
/* To run the nop during measurement:
it's the best case for low current
until counter reach detected by IT --> Idd_WakeUP */
do{
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
__NOP(); __NOP(); __NOP(); __NOP();
} while (Idd_WakeUP == FALSE );
#endif
PWR_EnterLowPowerRunMode(DISABLE);
while(PWR_GetFlagStatus(PWR_FLAG_REGLP) != RESET) ;
break;
/* SLEEP LOW POWER mode
Measurement done to MSI 32 Khz without RTC
*/
case MCU_LP_SLEEP:
/* Disable PVD */
PWR_PVDCmd(DISABLE);
/* Enable Ultra low power mode */
PWR_UltraLowPowerCmd(ENABLE);
/* To save the RCC configuration registers */
Config_RCC(&SavRCC);
/* To stop the sys tick for avoid IT */
SysTick->CTRL = 0;
/* Swith in MSI 32KHz */
SetHSICLKToMSI(RCC_MSIRange_0,DIV2,NoRTC) ;
#ifdef TESTINRAM
DisableInterrupts();
EnterLPSLEEPModeRAM();
EnableInterrupts();
#else
/* Falling edge for start counter */
GPIO_LOW(CTN_GPIO_PORT,CTN_CNTEN_GPIO_PIN);
/* Request Wait For Interrupt */
PWR_EnterSleepMode(PWR_Regulator_LowPower,PWR_SLEEPEntry_WFI);
#endif
break;
/* STOP modes
Measurement done to MSI 32 Khz without or with RTC
*/
case MCU_STOP_NoRTC:
case MCU_STOP_RTC:
/* Disable PVD */
PWR_PVDCmd(DISABLE);
/* Enable Ultra low power mode */
PWR_UltraLowPowerCmd(ENABLE);
/* To save the RCC configuration registers */
Config_RCC(&SavRCC);
/* To stop the sys tick for avoid IT */
SysTick->CTRL = 0;
/* Swith in MSI 32KHz */
if( Mcu_State == MCU_STOP_NoRTC )
SetHSICLKToMSI(RCC_MSIRange_0,DIV2,NoRTC) ;
else
SetHSICLKToMSI(RCC_MSIRange_0,DIV2,WITHRTC) ;
/* Falling edge for start counter */
GPIO_LOW(CTN_GPIO_PORT,CTN_CNTEN_GPIO_PIN);
/* Request Wait For Interrupt */
PWR_EnterSTOPMode(PWR_Regulator_LowPower,PWR_STOPEntry_WFI);
break;
/* Standby mode without RTC
Measurement done to MSI 32 Khz without RTC
*/
case MCU_STBY:
/* Disable PVD */
PWR_PVDCmd(DISABLE);
/* Enable Ultra low power mode */
PWR_UltraLowPowerCmd(ENABLE);
RTC_OutputTypeConfig(RTC_OutputType_PushPull);
RTC_OutputConfig(RTC_Output_WakeUp,RTC_OutputPolarity_High);
/* To configure PC13 WakeUP output */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 ;
//GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 ;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_400KHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_Init( GPIOC, &GPIO_InitStructure);
// GPIO_Init( GPIOA, &GPIO_InitStructure);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource13,GPIO_AF_RTC_AF1) ;
//GPIO_PinAFConfig(GPIOA, GPIO_PinSource0,GPIO_AF_RTC_AF1) ;
Config_RCC(&SavRCC);
SysTick->CTRL = 0;
/* Swith in MSI 32KHz */
SetHSICLKToMSI(RCC_MSIRange_0,DIV2,NoRTC) ;
PWR_WakeUpPinCmd(PWR_WakeUpPin_1,ENABLE);
PWR_UltraLowPowerCmd(ENABLE);
PWR_EnterSTANDBYMode();
/* Stop here WakeUp EXIT on RESET */
break;
}
SetHSICLK();
Config_Systick();
RCC->AHBENR = SavRCC.AHBENR;
PWR_VoltageScalingConfig(PWR_VoltageScaling_Range1);
/* Wait Until the Voltage Regulator is ready */
while (PWR_GetFlagStatus(PWR_FLAG_VOS) != RESET) ;
/* Read ADC for current measurmeent */
adc_measure = Current_Measurement();
/* ICC_CNT_EN Hi */
GPIO_HIGH(CTN_GPIO_PORT,CTN_CNTEN_GPIO_PIN);
UserButton = TRUE;
/* To restore RCC registers */
RCC->APB1ENR = SavRCC.APB1ENR;
RCC->APB2ENR = SavRCC.APB2ENR;
RCC->AHBLPENR = SavRCC.AHBLPENR;
RCC->APB1LPENR = SavRCC.APB1LPENR;
RCC->APB2LPENR = SavRCC.APB2LPENR;
/* Need to reinit RCC for LCD*/
RCC_Configuration();
PWR_EnterLowPowerRunMode(DISABLE);
/* Disable Ultra low power mode */
PWR_UltraLowPowerCmd(DISABLE);
/* Disable FLASH during SLeep LP */
FLASH_SLEEPPowerDownCmd(DISABLE);
Restore_GPIO_Config();
/* Clear Wake Up flag */
PWR_ClearFlag(PWR_FLAG_WU);
/* Enable PVD */
PWR_PVDCmd(ENABLE);
LCD_GLASS_Init();
return (adc_measure);
}
/**
* @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)
{
RTC_InitTypeDef RTC_InitStructure;
RTC_AlarmTypeDef RTC_AlarmStructure;
RTC_TimeTypeDef RTC_TimeStructure;
/* 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_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 = 0x08;
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();
/* Infinite loop */
while (1)
{
}
}
/**
* @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)
{
}
}
static mp_obj_t py_standby(void) {
PWR_EnterSTANDBYMode();
return mp_const_none;
}