power_main.c

用 Hitex 工具软件开发 stm32 的例子

/*-----------------------------------------------------------------------------------
* Function Name  : Disable_Exti
* Description    : Disable the external interrupts
* Input          : None
* Output         : None
* Return         : None
-----------------------------------------------------------------------------------*/
void Disable_Exti(void)
{
   EXTI_ClearITPendingBit(EXTI_Line2);
   EXTI_InitStructure.EXTI_Line = EXTI_Line2;
//   EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Event;
   EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
   EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
   EXTI_InitStructure.EXTI_LineCmd = DISABLE;
   EXTI_Init(&EXTI_InitStructure);
}
/*-----------------------------------------------------------------------------------
* Function Name  : SetPowerMode
* Description    : Change the Power Mode
* Input          : None
* Output         : None
* Return         : None
-----------------------------------------------------------------------------------*/
void SetPowerMode(void)
{
   switch (PowerModes[1]) {
    case WakeUp_Set_ExtInt :   /* Set the System to wakeup external event */
                              EXTI_InitStructure.EXTI_LineCmd = ENABLE;
                              break;
    case WakeUp_Set_USART :    /* Set the System to wakeup USART event */
                              EXTI_InitStructure.EXTI_LineCmd = ENABLE;
                              break;
    case WakeUp_Set_RTCAlarm : /* Set the System to wakeup with RTC */
                              RTC_WaitForLastTask();
                              RTC_ITConfig(RTC_IT_ALR, ENABLE);
                              PWR_WakeUpPinCmd(ENABLE);
                              break;
    case WakeUp_Set_WakeupPin : /* Set the System to wakeup on WakeupPin */
                              PWR_WakeUpPinCmd(ENABLE);
                              break;
    case WakeUp_Set_Reset :   /* Set the System to wakeup on Reset */
                              EXTI_InitStructure.EXTI_LineCmd = ENABLE;
                              break;
    default :                 PWR_WakeUpPinCmd(ENABLE);
                              break;
   }

   if (PowerModes[0] != Power_Mode_Running) /* low power mode disable LED */
   {
      TimeTick = 0;
      GPIO_WriteBit(GPIOB, GPIO_Pin_5, Bit_RESET);
   }
   switch (PowerModes[0]) {
    case Power_Mode_Sleep :   /* Set the System in Sleep Mode */
                              //GPIO_Config_ALL_AIN();
                              /* Disable the Jtag Debug Port SWJ-DP */
                              //GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable, ENABLE); 
                              Enable_Exti();
                              //Systick_DeConfiguration();
                              SysTick_ITConfig(DISABLE);
                              All_PeriphClock_Disable();
                              __WFI();
                              //Systick_Configuration();
                              SysTick_ITConfig(ENABLE);
                              Disable_Exti();
                              //GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable, DISABLE); 
                              //RCC_Configuration();
                              //GPIO_Configuration();
                              HW_ReConfig();
                              break;
    case Power_Mode_Stop :    /* Request to enter STOP mode with regulator in low power mode */
                            //  GPIO_Config_ALL_AIN();
                            //  GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable, ENABLE);
                              Enable_Exti();
                              /* Desable the SRAM and FLITF clock in Stop mode */ 
                            //  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_SRAM|RCC_AHBPeriph_FLITF, DISABLE);
                            //  All_PeriphClock_Disable();
                            //  RCC_SYSCLKConfig(RCC_SYSCLKSource_HSE);
                              PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
                            //  All_PeriphClock_Ensable();
                            //  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_SRAM|RCC_AHBPeriph_FLITF, ENABLE);
                            //  GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable, DISABLE); 
                              Disable_Exti();
                              RCC_Configuration();
                            //  GPIO_Configuration();
                              break;
    case Power_Mode_Standby : /* Set the System in Standby Mode */
                              Enable_Exti();
                              PWR_EnterSTANDBYMode();
                              break;
    case Power_Mode_RTC_Alarm : /* Set the System in Standby Mode */
                              Enable_Exti();
                              PWR_EnterSTANDBYMode();
                              break;
    case Power_Mode_Running : Disable_Exti();
                              break;
    default :                 /* not implemented */
                              protocol_SendError (Err_NotImplemented);
                              break;
   }
}
/*-----------------------------------------------------------------------------------
* Function Name  : GetPowerMode
* Description    : Check the Power Mode
* Input          : None
* Output         : None
* Return         : None
-----------------------------------------------------------------------------------*/
void GetPowerMode(void)
{
   PowerModes[0] = Power_Mode_Running;
   PowerModes[1] = WakeUp_Set_ExtInt;
}

/*-----------------------------------------------------------------------------------*/

u32 temp = 0;
void CommPwr (void)
{
   u8 i = 0;
   CommTask->CommandNew = FALSE;
   switch (CommTask->Command) {
    case Cmd_Get_PLL_Settings : /* GUI   Status request of the PLL Settings */
                           protocol_SendFrame (Rep_Info_PLL_Settings, (u8 *)PLLSet,5);
                           break;
    case Cmd_Get_Power_Mode : /* GUI   Status request of the Power Modes */
                           GetPowerMode();
                           protocol_SendFrame (Rep_Info_Power_Mode, (u8 *)PowerModes,2);
                           break;
    case Cmd_Set_Power_Mode     : /*   GUI   Set the Power Modes */
                           CommTask->Command = Cmd_Idle;/* Answer to status request */
                           CommTask->DataLength = 0;
                           PowerModes[0] = CommTask->Data[0];
                           PowerModes[1] = CommTask->Data[1];
                           SetPowerMode();
                           break;
    case Cmd_Get_Periph_Gating  : /* GUI   Status request of the perriph Gating */
                           GetPeripheralGating();
                           protocol_SendFrame (Rep_Info_Periph_Gating, (u8 *)GatingSet,6);
                           break;
    case Cmd_Set_Periph_Gating      : /* GUI   Set the IP address */
                           CommTask->Command = Cmd_Idle;/* Answer to status request */
                           CommTask->DataLength = 0;
                           for (i=0; i<6 ;i++)
                              GatingSet[i] = CommTask->Data[i];
                           SetPeripheralGating();
                           break;
    case Cmd_Set_PLL_Settings :
                           CommTask->Command = Cmd_Idle;/* Answer to status request */
                           CommTask->DataLength = 0;
                           for (i=0; i<5 ;i++)
                              PLLSet[i] = CommTask->Data[i];
                           SetPLLSettings();
                           break;
    case Cmd_Get_CPU_Clock  : /* GUI   Status request of the CPU Clock set */
                           protocol_SendFrame (Rep_Info_CPU_Clock, (u8 *)&CPU_Clock_Selected,1);
                           break;
    case Cmd_Set_CPU_Clock      : /* GUI   Set the CPU Clock Set */
                           CommTask->Command = Cmd_Idle;/* Answer to status request */
                           CommTask->DataLength = 0;
                           CPU_Clock_Selected = CommTask->Data[0];
                           break;
    case Cmd_Get_Backup_Data      : /* GUI   Request for  */
                           SendTask->Data[0] = BKP_ReadBackupRegister(BKP_DR1)>>8;
                           SendTask->Data[1] = BKP_ReadBackupRegister(BKP_DR1);
                           SendTask->Data[2] = BKP_ReadBackupRegister(BKP_DR2)>>8;
                           SendTask->Data[3] = BKP_ReadBackupRegister(BKP_DR2);
                           SendTask->Data[4] = BKP_ReadBackupRegister(BKP_DR3)>>8;
                           SendTask->Data[5] = BKP_ReadBackupRegister(BKP_DR3);
                           SendTask->Data[6] = BKP_ReadBackupRegister(BKP_DR4)>>8;
                           SendTask->Data[7] = BKP_ReadBackupRegister(BKP_DR4);
                           SendTask->Data[8] = BKP_ReadBackupRegister(BKP_DR5)>>8;
                           SendTask->Data[9] = BKP_ReadBackupRegister(BKP_DR5);
                           protocol_SendFrame (Rep_Info_Backup_Data, (u8 *)&SendTask->Data,10);
                           break;
    case Cmd_Set_Backup_Data      : /* GUI   Set the Backup Data */
                           SendTask->ReplyNew = FALSE;
                           BKP_WriteBackupRegister(BKP_DR1, (u16)(CommTask->Data[0]<<8) + CommTask->Data[1]);
                           BKP_WriteBackupRegister(BKP_DR2, (u16)(CommTask->Data[2]<<8) + CommTask->Data[3]);
                           BKP_WriteBackupRegister(BKP_DR3, (u16)(CommTask->Data[4]<<8) + CommTask->Data[5]);
                           BKP_WriteBackupRegister(BKP_DR4, (u16)(CommTask->Data[6]<<8) + CommTask->Data[7]);
                           BKP_WriteBackupRegister(BKP_DR5, (u16)(CommTask->Data[8]<<8) + CommTask->Data[9]);
                           break;
    case Cmd_Get_RTC :     /* GUI Set the IP address */
                           temp = RTC_GetCounter();
                           RTCVal[0]= (u8)temp;
                           RTCVal[1]= (u8)(temp>>8);
                           RTCVal[2]= (u8)(temp>>16);
                           RTCVal[3]= (u8)(temp>>24);
                           protocol_SendFrame (Rep_Info_RTC, (u8 *)&RTCVal,4);
                           break;
    case Cmd_Set_RTC      : /* GUI   Set the IP address */
                           for (i=0; i<4 ;i++)
                              RTCVal[i] = CommTask->Data[i];
                           RTC_WaitForLastTask();
                           RTC_SetCounter((u32)(RTCVal[3]<<24)+(u32)(RTCVal[2]<<16)+(u32)(RTCVal[1]<<8)+(u32)RTCVal[0]);
                           break;
    case Cmd_Get_RTC_Alarm :
                           protocol_SendFrame (Rep_Info_RTC_Alarm, (u8 *)&RTCAlarm,4);
                           break;
    case Cmd_Set_RTC_Alarm      : /* GUI   Set the IP address */
                           for (i=0; i<4 ;i++)
                              RTCAlarm[i] = CommTask->Data[i];
                           RTC_WaitForLastTask();
                           RTC_SetAlarm((u32)(RTCAlarm[3]<<24)+(u32)(RTCAlarm[2]<<16)+(u32)(RTCAlarm[1]<<8)+(u32)RTCAlarm[0]);
                           break;
    case Cmd_Set_Stick_LED : /* GUI Set the LED mode off, on, blink */
                           if (CommTask->Data[0] == LED_Off)
                           {
                              LEDBlinkState.enabled = FALSE;
                              GPIO_WriteBit(GPIOB, GPIO_Pin_5, Bit_RESET);
                           }
                           else if (CommTask->Data[0] == LED_On)
                           {
                              LEDBlinkState.enabled = FALSE;
                              GPIO_WriteBit(GPIOB, GPIO_Pin_5, Bit_SET);
                           }
                           else if (CommTask->Data[0] == LED_Blink_On)
                              LEDBlinkState.enabled = TRUE;
                           break;
    default :              /* not implemented */
                           protocol_SendError (Err_NotImplemented);
                           break;
    }
}