WDFJKEY/source/user/mapp_pwr.c

//==================================================================
// 
//	Filename: mapp_pwr.c
//	Description: Power driver
// 
//------------------------------------------------------------------
// 
// version: 
// date: 23:54pm, 08.Apr.2012, by Sirius
//	Description: 
// 
//------------------------------------------------------------------
//==================================================================

/*------------------------------------------------------------------------------
 *						I N C L U D E
 *------------------------------------------------------------------------------*/
#include "stm32f0xx.h"
#include "general.h"
#include "main.h"
#include "mapp_can.h"
#include "mapp_ext.h"
#include "mapp_gpio.h"
#include "mapp_pwr.h"
#include "mapp_msg.h"
#include "mapp_arm.h"
#include "mapp_uart1.h"
#include "mapp_arm.h"



/*------------------------------------------------------------------------------
 *						D E F I N E
 *------------------------------------------------------------------------------*/
/* Macro define for start or sleep wait timer */
#define WAIT_SYS_OFF_TIMER         (OS_TIMER_1S)       /* Timer: ON -> SLEEP */
#define WAIT_SYS_RUN_TIMER         (OS_TIMER_5S)        /* Timer: SLEEP ->ON  */


/* Wake-up EXTI define for sleep mode */
#define WAKE_UP_GPIO_PORT          (EXTI_PortSourceGPIOC)   /* Timer: ON -> SLEEP */
#define WAKE_UP_GPIO_PIN           (GPIO_PinSource5)       /* Timer: ON -> SLEEP */
#define WAKE_UP_EXTI_LINE          (EXTI_Line5)            /* Timer: ON -> SLEEP */
#define WAKE_UP_EXTI_EDGE          (EXTI_Trigger_Falling)   /* Timer: ON -> SLEEP */

/*------------------------------------------------------------------------------
 *						S T R U C T
 *------------------------------------------------------------------------------*/


/*------------------------------------------------------------------------------
 *						S T A T I C - V A R I A B L E S
 *------------------------------------------------------------------------------*/
T_PWR_CFG      gtPwrCfg ;   

/*------------------------------------------------------------------------------
 *						E X T E R N
 *------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------
 *						P R O T O T Y P E
 *------------------------------------------------------------------------------*/
static void s_PwrPeripheralCfg(FunctionalState stat);
static void s_PwrRCCCfg(FunctionalState stat);


/*----------------------------------------------------------------------
// Function uses    : PwrVarInit
// Input  parameter : 
// Output parameter : 
// Use  Function    : Power task variables init.
// Reserve  date    : 20:34pm, 01.Mar.2013, written by Sirius
 ----------------------------------------------------------------------*/
void PwrVarInit(void)
{
    gtPwrCfg.state      = POWER_ON_RESET;
    gtPwrCfg.taskTmr    = 0;
    gtPwrCfg.sleepMode  = SLEEP_INTO_NORMAL;
    gtPwrCfg.sleepState = FALSE;
    gtPwrCfg.CanLostTmr =0;
}

/***************************************
* 函数描述：外部中断0服务程序
* 输入参数：No
* 返 回 值：No
* 说    明：
* 修改记录： 
****************************************/	  
void DMA1_Channel4_5_IRQHandler(void)
{
   if(EXTI_GetITStatus(EXTI_Line14) != RESET)//判断线0上的中断是否发生，可以理解为标志位
   {
     /* Toggle LED3 and LED4 */
//     GPIO_WriteBit(GPIOC, GPIO_Pin_8, 
// 		             (BitAction)((1-GPIO_ReadOutputDataBit(GPIOC, GPIO_Pin_8))));
//     GPIO_WriteBit(GPIOC, GPIO_Pin_9, 
// 		             (BitAction)((1-GPIO_ReadOutputDataBit(GPIOC, GPIO_Pin_9))));
     /* Clear the EXTI line 0 pending bit */
     EXTI_ClearITPendingBit(EXTI_Line14);//清除LINE0上的中断标志位
   }
}

void Sys_Stop(void)
{  
  SysTick->CTRL = 0x00;
   SysTick->VAL = 0x00;

	RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR , ENABLE);
	PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
}

/***************************************
* 函数描述：外部中断初始化
* 输入参数：No
* 返 回 值：No
* 说    明：
* 修改记录： 
****************************************/	 
void EXTI_KEY_Init(void)
{
   EXTI_InitTypeDef EXTI_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
  GPIO_InitTypeDef GPIO_InitStructure;
	
	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOF, ENABLE);
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	 GPIO_SetBits(GPIOA, GPIO_Pin_10);
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 ;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
	GPIO_Init(GPIOF, &GPIO_InitStructure);
	
	SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOF, EXTI_PinSource0);
	/* Configure Button EXTI line */
	EXTI_InitStructure.EXTI_Line = EXTI_Line0;
	EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
	EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;  
	EXTI_InitStructure.EXTI_LineCmd = ENABLE;
	EXTI_Init(&EXTI_InitStructure);
		
		
	NVIC_InitStructure.NVIC_IRQChannel = EXTI0_1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
/*
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);				//使能系统时钟配置

	  	
	SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA, EXTI_PinSource14); //配置GPIO与中断线的映射关系
	EXTI_InitStruct.EXTI_Line = EXTI_Line14;                       //中断线标号0
	EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;              //外部中断模式
	EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising_Falling;          //下降沿中断
	EXTI_InitStruct.EXTI_LineCmd = ENABLE;                        //中断线使能
	EXTI_Init(&EXTI_InitStruct); 
	
	NVIC_InitStruct.NVIC_IRQChannel = EXTI4_15_IRQn;
	NVIC_InitStruct.NVIC_IRQChannelPriority = 0x00;
	NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStruct);*/
}


/*----------------------------------------------------------------------
// Function uses    : PwrTask
// Input  parameter : 
// Output parameter : 
// Use  Function    : Main task for power manage.
// Reserve  date    : 20:07pm, 20.Feb.2013, written by Sirius
 ----gtPwrCfg.state------------------------------------------------------------------*/
void PwrTask(void)
{    
    switch (gtPwrCfg.state) {
        case POWER_ON_RESET:
					
            gtPwrCfg.state++;
            
            //------------------------------------------------------------------
            // clear task timer before start.
            // 21:59pm, 29.Aug.2012, modified by Sirius
            //------------------------------------------------------------------
             gtPwrCfg.taskTmr = 0;
            break;
			
				case POWER_ON_WAIT:
					 if (gtPwrCfg.taskTmr <= OS_TIMER_1S) {
                break;
            }	
				
					 gtPwrCfg.taskTmr = 0;
						 gtPwrCfg.state++;
					break;
				case POWER_ON_RESET9212:
					 if (gtPwrCfg.taskTmr <= OS_TIMER_2S) {
                break;
            }	
					 

					  gtPwrCfg.state++;
					break;
				case POWER_ON_CONFIG:
						gtPwrCfg.taskTmr  =0;
				  gtPwrCfg.state++;
				break;
                
        case POWER_ON_INIT:                             /* Init module hardware                */
          //  if (gtPwrCfg.taskTmr <= WAIT_SYS_RUN_TIMER) {
          //      break;
          //  }	

						
           // gtArm.i2cstate = I2C_ON_RESET;
            gtPwrCfg.CanLostTmr =0;
						gtPwrCfg.taskTmr  =0;
            gtPwrCfg.state++;
            break;
        case   POWER_LED_IO_INIT:
					  if (gtPwrCfg.taskTmr <= WAIT_SYS_RUN_TIMER) {
                break;
            }	
		    
					 gtPwrCfg.state++;
					break;
        case POWER_SYSTEM_RUN:
            //------------------------------------------------------------------
            // monitor system ACC state.
            // 21:54pm, 27.Nov.2012, modified by Sirius
            //------------------------------------------------------------------
					 // OSQPost(ArmMsgQueue, ARM_MSG_KEY, 0); //dwdtest
            break;
                
        case POWER_OFF_INIT:
            //------------------------------------------------------------------
            // Sleep if all communication finished, otherwise recover.
            // 21:57pm, 27.Nov.2012, modified by Sirius
            //------------------------------------------------------------------
            if (gtPwrCfg.taskTmr <= WAIT_SYS_OFF_TIMER) {
               break;
            }
      
            gtPwrCfg.taskTmr = 0;
            gtPwrCfg.state = POWER_OFF_SLEEP;
            break;
            
        case POWER_OFF_SLEEP:
            //------------------------------------------------------------------
            // Wait 100ms for CAN sleep process stable.
            //------------------------------------------------------------------
            if (gtPwrCfg.taskTmr < OS_TIMER_100MS) {
                break;
            }
						//Befor_goto_Stop();
				    EXTI_KEY_Init(); //外部中断初始化
			

					  Sys_Stop();//可以用外部中断唤醒，如PB0
						SystemInit();

						gtArm.workmode =1;
						
					
						 if (SysTick_Config(SystemCoreClock / OS_TICKS_PER_SEC))
							{
									/* Capture error */
									while (1);
							}
            gtPwrCfg.state   = POWER_LED_IO_INIT;
            gtPwrCfg.taskTmr = 0;
            break;
            
        default:
            break;
    }
}

/*----------------------------------------------------------------------
// Function uses    : PwrTaskTmr
// Input  parameter : 
// Output parameter : 
// Use  Function    :
// Reserve  date    : 09:11am, 30.Aug.2012, written by Sirius
 ----------------------------------------------------------------------*/
void PwrTaskTmr(void)
{
    if (gtPwrCfg.taskTmr != 0xffff) {gtPwrCfg.taskTmr++;}
     if (gtPwrCfg.CanLostTmr != 0xffff)  {gtPwrCfg.CanLostTmr++;}
}

/*----------------------------------------------------------------------
// Function uses    : PwrWakeupISRHandler
// Input  parameter : 
// Output parameter : 
// Use  Function    : External wake-up ISR for system power.
// Reserve  date    : 19:34pm, 01.Mar.2013, written by Sirius
 ----------------------------------------------------------------------*/
void PwrWakeupISRHandler(void)
{
    if (EXTI_GetITStatus(WAKE_UP_EXTI_LINE) != RESET) { 
        /* Clear the Key Button EXTI line pending bit */  
        EXTI_ClearFlag(WAKE_UP_EXTI_LINE);
        //EXTI->IMR &= ~EXTI_Line12;
        gtPwrCfg.sleepState = FALSE;
    }
}


//---------------------------------------------------------------------------
/*----------------------------------------------------------------------
// Function uses    : s_PwrPeripheralCfg
// Input  parameter : 'stat': DISABLE or ENABLE.
// Output parameter : 
// Use  Function    : disalbe or re-enable peripheral & interrupt before system sleep.
// Reserve  date    : 09:45am, 28.Nov.2012, written by Sirius
 ----------------------------------------------------------------------*/
static void s_PwrPeripheralCfg(FunctionalState stat)
{
    if (stat == DISABLE) {
    	ADC_Cmd(ADC1, stat);
        Uart1CfgDisable();
   
   
        SysTick->CTRL  &= (U32)(~SysTick_CTRL_ENABLE_Msk);
    } else {
    	GpioCfgInit();
    	Uart1CfgInit();
   
	//AdcCfgInit();

     
        SysTick->CTRL  |= SysTick_CTRL_ENABLE_Msk;        
    }
}

/*----------------------------------------------------------------------
// Function uses    : s_PwrRCCCfg
// Input  parameter : 'stat': DISABLE or ENABLE.
// Output parameter : 
// Use  Function    : Configure RCC for power module.
// Reserve  date    : 20:06pm, 04.Mar.2013, written by Sirius
 ----------------------------------------------------------------------*/
static void s_PwrRCCCfg(FunctionalState stat)
{
    if (stat == DISABLE) {
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1,DISABLE);
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, DISABLE);
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, DISABLE);
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, DISABLE);
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART4, DISABLE);
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN, DISABLE);
        //RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2, DISABLE);
        //RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, DISABLE);
        //RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, DISABLE);
	    //RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, DISABLE);
        //RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, DISABLE);
    	//RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, DISABLE);

	//#if 0 //dwd170224
        RCC_HSICmd(ENABLE);
        while ((RCC->CR & RCC_CR_HSIRDY) != RCC_CR_HSIRDY){}       /* Wait till HSI ready */
        IWDG_ReloadCounter();
        RCC_SYSCLKConfig(RCC_SYSCLKSource_HSI);
        while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_HSI){}   /* Wait till HSI used as system clock source */
        IWDG_ReloadCounter();
        RCC_PLLCmd(DISABLE);
        //RCC_PLL2Cmd(DISABLE);
        RCC_HSEConfig(RCC_HSE_OFF);
        while ((RCC->CR & RCC_CR_HSERDY) == RCC_CR_HSERDY){}       /* Wait till HSE OFF */

        FLASH_SetLatency(FLASH_Latency_0);
        RCC_HCLKConfig(RCC_SYSCLK_Div16);///125k
        IWDG_ReloadCounter();
     //  #endif
	   
    } else {
	
	//#if 0 //dwd170224
	    RCC_HCLKConfig(RCC_SYSCLK_Div1);
        FLASH_SetLatency(FLASH_Latency_1);
        IWDG_ReloadCounter();
        RCC_HSEConfig(RCC_HSE_ON);
        while ((RCC->CR & RCC_CR_HSERDY) != RCC_CR_HSERDY){}       /* Wait till HSE ON */
        IWDG_ReloadCounter();
        //RCC_PLL2Cmd(ENABLE);
        //while ((RCC->CR & RCC_CR_PLL2RDY) != RCC_CR_PLL2RDY){}     /* Wait till PLL2 ON */
        //IWDG_ReloadCounter();
        RCC_PLLCmd(ENABLE);
        while ((RCC->CR & RCC_CR_PLLRDY) != RCC_CR_PLLRDY){}       /* Wait till PLL ON */
        IWDG_ReloadCounter();
        RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
        while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_PLL){}   /* Wait till HSE used as system clock source */
       IWDG_ReloadCounter();
//	#endif
        
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1,ENABLE);
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
    	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
    	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
    	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART4, ENABLE);
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN, ENABLE);
        //RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2, ENABLE);
        //RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
	//RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);		
        //RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
    	//RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
    }
}


/*------------------------------- E O F ----------------------------------------*/