STOP休眠模式

  2. #include "stm32f10x_conf.h"
  3. #include "bsp_include.h"
  6. uint8_t GeneralAwakeFlag = 0; //退出休眠标志
  7. Sleep_Struct SleepStruct;
  9. //*************************************************进入STOP休眠后RTC唤醒配置
  10. static void RTC_Configuration(void)
  11. {
  12.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR|RCC_APB1Periph_BKP, ENABLE);
  13.   PWR_BackupAccessCmd(ENABLE);
  14.   BKP_DeInit();
  16.   RCC_LSICmd(ENABLE);         /*使用内部40K振荡器*/
  17.   RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI); // 配置内部时钟
  18.   RCC_RTCCLKCmd(ENABLE);      /*使能RTC*/
  19.   RTC_WaitForSynchro();       /*等待时钟同步*/
  20.   RTC_WaitForLastTask();      /*等待写操作完成*/
  21.   RTC_SetPrescaler(40000);    /*1秒计数*/
  22.   RTC_WaitForLastTask();
  23. }
  24. static void RTC_Alarm_EXTI_Config(uint16_t sec)
  25. {/*配置RTC闹钟事件到中断17*/
  26.   EXTI_InitTypeDef EXTI_InitStructure;
  28.   EXTI_ClearITPendingBit(EXTI_Line17);
  29.   EXTI_InitStructure.EXTI_Line = EXTI_Line17;
  30.   EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  31.   EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
  32.   EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  33.   EXTI_Init(&EXTI_InitStructure);
  35.   RTC_SetAlarm(RTC_GetCounter()+sec);/*设置N秒后唤醒*/
  36.   RTC_WaitForLastTask();
  37. }
  39. static void RTC_Alarm_NVIC_Config(void)
  40. {/*配置RTC闹钟中断*/
  41.   NVIC_InitTypeDef NVIC_InitStructure;
  43.   NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
  45.   NVIC_InitStructure.NVIC_IRQChannel = RTCAlarm_IRQn;
  46.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
  47.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  48.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  49.   NVIC_Init(&NVIC_InitStructure);
  51.   RTC_ITConfig(RTC_IT_ALR, ENABLE);/*使能中断*/
  52.   RTC_WaitForLastTask();
  53. }
  55. void RTC_IRQHandler(void)
  56. {// RTC中断
  57.   if (RTC_GetITStatus(RTC_IT_SEC) != RESET)
  58.   {
  59.     RTC_ClearITPendingBit(RTC_IT_SEC);
  60.     RTC_WaitForLastTask();
  61.   }
  62. }
  63. void RTCAlarm_IRQHandler(void)
  64. {// RTC告警中断
  65.   if(RTC_GetFlagStatus(RTC_IT_ALR))
  66.   {
  67.     RTC_ClearITPendingBit(RTC_IT_ALR);
  68.     RTC_WaitForLastTask();
  69.     EXTI_ClearITPendingBit(EXTI_Line17);/*清除闹钟中断*/
  70.     if(PWR_GetFlagStatus(PWR_FLAG_WU) != RESET)
  71.     {
  72.       PWR_ClearFlag(PWR_FLAG_WU);/*清除唤醒标志*/
  73.     }
  74.   }
  75. }
  76. //*************************************************RTC唤醒配置
  78. //static void LowPower_InStandby(void)
  79. //{/*进入待机模式，待机模式下唤醒，程序复位运行*/
  80. //  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR , ENABLE);
  81. //  RTC_Configuration();          /*配置RTC时钟*/
  82. //  RTC_Alarm_EXTI_Config(10);    /*配置闹钟唤醒*/
  83. //  //PWR_WakeUpPinCmd(ENABLE);   /*使能WAKEUP脚唤醒*/
  84. //  IWDG_Config();                /*使用独立看门狗唤醒*/
  85. //  PWR_EnterSTANDBYMode();       /*进入待机模式*/
  86. //}
  88. //中断配置,只需要配置唤醒的中断
  89. static void Wake_EXTI_Intit(void)
  90. {
  91.     NVIC_InitTypeDef NVIC_InitStructure;
  92.     EXTI_InitTypeDef EXTI_InitStructure;
  93.     GPIO_InitTypeDef GPIO_InitStructure;
  95.     /*    设置中断向量表是在RAM中或是flash中，并指出器偏移量    */
  96. #ifdef  VECT_TAB_RAM
  97.       /* Set the Vector Table base location at 0x20000000 */
  98.       NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
  99. #else  /* VECT_TAB_FLASH  */
  100.   #ifdef USER_BOOTLOADER
  101.     NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x2000); // 中断向量偏移
  102.     #else
  103.     NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);
  104.     #endif
  105. #endif  
  106.      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0); 
  108.     // PA0 充电唤醒中断配置
  109.     GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_0 ;
  110.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING ;//GPIO_Mode_AIN GPIO_Mode_IN_FLOATING
  111.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  112.     GPIO_Init(GPIOA, &GPIO_InitStructure);
  114.     GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource0);
  115.     EXTI_InitStructure.EXTI_Line = EXTI_Line0;
  116.     EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;//EXTI_Mode_Event    EXTI_Mode_Interrupt
  117.     EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
  118.     EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  119.     EXTI_Init(&EXTI_InitStructure);
  120.     EXTI_ClearITPendingBit(EXTI_Line0);
  122.     NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;     
  123.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; 
  124.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;          
  125.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;           
  126.     NVIC_Init(&NVIC_InitStructure);
  128.     // PA1 通信唤醒口
  129.     GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_1 ;
  130.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING ;//GPIO_Mode_AIN GPIO_Mode_IN_FLOATING
  131.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  132.     GPIO_Init(GPIOA, &GPIO_InitStructure);
  134.     GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource1);
  135.     EXTI_InitStructure.EXTI_Line = EXTI_Line1;
  136.     EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;//EXTI_Mode_Event    EXTI_Mode_Interrupt
  137.     EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
  138.     EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  139.     EXTI_Init(&EXTI_InitStructure);
  140.     EXTI_ClearITPendingBit(EXTI_Line1);
  142.     NVIC_InitStructure.NVIC_IRQChannel = EXTI1_IRQn;     
  143.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; 
  144.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;          
  145.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;           
  146.     NVIC_Init(&NVIC_InitStructure);
  149.     // RTC
  150.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
  151.     NVIC_InitStructure.NVIC_IRQChannel = RTCAlarm_IRQn;
  152.       NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  153.       NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  154.       NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  155.       NVIC_Init(&NVIC_InitStructure);
  156. }
  159. //休眠前管脚关闭或开启
  160. void ALL_GPIO_Sleep_Init(void)
  161. {
  162.     GPIO_InitTypeDef GPIO_InitStructure;
  163.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
  164.     GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE); 
  165.     GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_All ;
  166.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN ;
  167.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  168.     GPIO_Init(GPIOA, &GPIO_InitStructure);
  170.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
  171.     GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_All ;
  172.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN ;
  173.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  174.     GPIO_Init(GPIOB, &GPIO_InitStructure);
  177.     //预充
  178.     RCC_APB2PeriphClockCmd(PRECHARGE_APB,ENABLE);
  179.     GPIO_InitStructure.GPIO_Pin =  PRECHARGE_PIN ;
  180.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;
  181.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  182.     GPIO_Init(PRECHARGE_PORT, &GPIO_InitStructure);
  183.     Relay_PreChargeOff(0);    
  185.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);
  186.     GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_All ;
  187.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN ;
  188.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  189.     GPIO_Init(GPIOC, &GPIO_InitStructure);
  191.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD,ENABLE);
  192.     GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_All ;
  193.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN ;
  194.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  195.     GPIO_Init(GPIOD, &GPIO_InitStructure);
  197.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE,ENABLE);
  198.     GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_All ;
  199.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN ;
  200.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  201.     GPIO_Init(GPIOE, &GPIO_InitStructure);
  203.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOF,ENABLE);
  204.     GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_All ;
  205.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN ;
  206.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  207.     GPIO_Init(GPIOF, &GPIO_InitStructure);
  209.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOG,ENABLE);
  210.     GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_All ;
  211.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN ;
  212.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  213.     GPIO_Init(GPIOG, &GPIO_InitStructure);
  216.     /*放电mos控制*/
  217.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
  218.     GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_10 ;
  219.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;
  220.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  221.     GPIO_Init(GPIOA, &GPIO_InitStructure);
  222.     GPIOA->BSRR = GPIO_Pin_10;// 打开放电mos
  224.     // 单片机给运放供电
  225.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
  226.     GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_3;
  227.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;
  228.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  229.     GPIO_Init(GPIOB, &GPIO_InitStructure);
  230.     GPIOB->BSRR = GPIO_Pin_3;// 打开放电mos
  231. }
  234. #if INSERT_DOG_ENABLE /*使用内部看门狗*/
  235. /**
  236.   * @brief  独立看门狗配置
  237.   * @param  NONE
  238.   * @retval NONE
  239. */
  240. void WatchDog_Config(void)
  241. { /*看门狗配置*/
  242.     RCC_LSICmd(ENABLE);
  243.     while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET)
  244.     {
  245.         ;
  246.     }
  247.     IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);
  248.     IWDG_SetPrescaler(IWDG_Prescaler_256); /*设置为秒超时复位*/
  249.     IWDG_SetReload(0xfff);
  250.     while (IWDG_GetFlagStatus(IWDG_FLAG_PVU) == RESET)
  251.     {
  252.         ;
  253.     }
  254.     IWDG_Enable();
  255. }
  256. #endif
  261. //休眠设置
  262. void InsertLowpowerInit(void)
  263. {
  264.     uint8_t ReadBackWatchdogFlag;
  266.     ReadBackWatchdogFlag = ReadLowPowerFlag();
  268.     if (ReadBackWatchdogFlag == LowPowerFlagValue)
  269.     {// 进入深度休眠
  270.         EnableInterrupt(); /*硬件初始化完成后开总中断*/
  271.         Re_LowPower_SEEP();
  272.     }
  273.     else
  274.     {
  275.         WatchDog_Config(); 
  276.     }
  277. }
  283. /******************************ADC通道配置**********************************/
  284. #define     ADC1_DR_Address    ((uint32_t)0x4001244C) /*!<ADC数据寄存器地址*/
  285. #define     ADC_CHANN_INUSE_NUM 1                     /*!<ADC通道使用数*/
  286. static uint16_t    ADCValueBuf[ADC_CHANN_INUSE_NUM];         /*!<采集数据缓存*/
  287. static const uint8_t TempChnnaIndex[]={0};
  288. static const uint8_t Sel_ADC_Chann[ADC_CHANN_INUSE_NUM]=
  289. {
  291.     ADC_Channel_6//,ADC_Channel_7,
  293. };/*!<温度采集通道*/
  295. /**
  296.   * @brief  ADC采集通道引脚配置
  297.   * @param  NONE
  298.   * @retval NONE
  299. */
  300. uint8_t EnterLowPower = 0; // 进入普通休眠标志
  301. static void ADC_ChannelPin_Config(void)
  302. {
  303.     GPIO_InitTypeDef  GPIO_InitStructure; 
  304.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;    /*模拟输入*/ 
  306.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);  
  308.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;//|GPIO_Pin_7; /*PA7*/
  309.     GPIO_Init(GPIOA, &GPIO_InitStructure); 
  310. }
  311. /**
  312.   * @brief  ADC模块初始化
  313.   * @param  NONE
  314.   * @retval NONE
  315. */
  316. void ADC_Mode_Init()
  317. {
  318.     ADC_InitTypeDef ADC_InitStructure;
  319.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);      /*打开ADC时钟*/
  321.     ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
  322.     ADC_InitStructure.ADC_ScanConvMode = ENABLE;              /*通道扫描模式*/
  323.     ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;//ENABLE;        /*连续转换模式*/
  324.     ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
  325.     ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;    /*数据右对齐*/
  326.     ADC_InitStructure.ADC_NbrOfChannel = ADC_CHANN_INUSE_NUM; /*通道个数*/
  327.     ADC_Init(ADC1, &ADC_InitStructure);
  329.     ADC_RegularChannelConfig(ADC1, Sel_ADC_Chann[0], 1, ADC_SampleTime_239Cycles5);
  331.     ADC_Cmd(ADC1, ENABLE);      /*打开ADC*/
  334.     ADC_StartCalibration(ADC1);                 /*启动ADC校准*/
  335.     while(ADC_GetCalibrationStatus(ADC1));      /*等待校准完成*/
  337.     ADC_SoftwareStartConvCmd(ADC1, ENABLE);     /*开始ADC数据采集*/
  338. }
  339. /**
  340.   * @brief  ADC模块初始化
  341.   * @param  NONE
  342.   * @retval NONE
  343. */
  344. static void ADC_Module_Init(void)
  345. {
  346.     ADC_ChannelPin_Config();
  348.     ADC_Mode_Init();    
  349. }
  352. // 延时
  353. static void _Delay_Nms_My(uint16_t Nms)
  354. {
  355.     uint16_t i=0,j=0;
  356.     while(i<Nms)
  357.     {
  358.         i++;
  359. #if SYSTEMCLOCK_24M  
  360.     j=4800;/*系统时钟24M*/
  361. #else    
  362.     //j=1600;/*系统时钟8M*/
  363.         j = 800;
  364. #endif    
  365.         while(j)
  366.         {
  367.           j--;
  368.         }
  369.     }
  370. }
  372. // 获取ADC采集数据
  373. u16 Get_Adc(u8 ch)   
  374. {
  375.     u16 dat = 0;
  376.     _Delay_Nms_My(200);
  377.     dat = ADC_GetConversionValue(ADC1);
  378.     return dat;  //返回最近一次ADC1规则组的转换结果
  379. }
  381. static RegisterGroup        BQ940RegDat;  /*!<寄存器数据*/
  382. static uint8_t BQ940_ChipFunctionConfig(void)
  383. {
  384.   uint8_t res = TRUE;
  386.   BQ940RegDat.SysCtrl1.Byte = 0;/*控制寄存器数据清零*/
  387.   BQ940RegDat.SysCtrl2.Byte = 0;/*控制寄存器数据清零*/
  388.   BQ940RegDat.SysCtrl1.Bits.ADC_EN = 0;/*不使能ADC*/
  391.   BQ940RegDat.SysCtrl2.Bits.DSG_ON = 1; // 放电mos打开
  392.   BQ940RegDat.SysCtrl2.Bits.CC_EN = 0;/*使能电流采集*/
  394.   BQ940RegDat.SysCtrl1.Byte = BQ940_WriteRegDat(REG_SYS_CTRL1,BQ940RegDat.SysCtrl1.Byte);
  395.   BQ940RegDat.SysCtrl2.Byte = BQ940_WriteRegDat(REG_SYS_CTRL2,BQ940RegDat.SysCtrl2.Byte);
  396.   return res;
  397. }
  400. static uint8_t SleepCnt = 0;
  401. void Re_LowPower(void)
  402. {
  403.     uint8_t i;
  404.     uint8_t sleep_cnt = 0;
  405.     uint8_t SaveInsertWdg;
  406.     float adc_val = 0;
  407.     NVIC_InitTypeDef NVIC_InitStructure;
  408.     EXTI_InitTypeDef EXTI_InitStructure;
  410. #if    INSERT_DOG_ENABLE/*使用内部看门狗*/
  411.     SaveInsertWdg = SleepFlagClear;
  412. #endif
  414.     ALL_GPIO_Sleep_Init(); // 进入休眠一脚配置
  416.     ADC_Cmd(ADC1, DISABLE);
  417.     DMA_Cmd(DMA1_Channel1, DISABLE);
  418.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, DISABLE);      /*关闭ADC时钟*/
  420.     while(1)
  421.     {    
  422.         Wake_EXTI_Intit();
  423.         SleepStruct.sleep_flag = 1;
  425.         /* RTC唤醒配置 */
  426.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR , ENABLE);
  427.         RTC_Alarm_NVIC_Config();
  428.         RTC_Configuration();          /*配置RTC时钟*/
  429.         RTC_Alarm_EXTI_Config(5);    /*配置闹钟唤醒*/
  431.         FeedInsertWatchDog();
  433.         SysTick->CTRL = 0x00; // 需要关闭滴答定时器,否则中断会唤醒
  434.         SysTick->VAL = 0x00;
  436.         PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);// 进入休眠
  439.         //------------------------------------通信中断关闭
  440.         GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource0);
  441.         EXTI_InitStructure.EXTI_Line = EXTI_Line0;
  442.         EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;//EXTI_Mode_Event    EXTI_Mode_Interrupt
  443.         EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
  444.         EXTI_InitStructure.EXTI_LineCmd = DISABLE;
  445.         EXTI_Init(&EXTI_InitStructure);
  446.         EXTI_ClearITPendingBit(EXTI_Line0);
  448.         NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;     
  449.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; 
  450.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;          
  451.         NVIC_InitStructure.NVIC_IRQChannelCmd = DISABLE;           
  452.         NVIC_Init(&NVIC_InitStructure);
  453.         //------------------------------------通信中断关闭
  457.         /* 休眠唤醒计数 */
  459.         SleepCnt++;
  460.         if(SleepCnt>84)// 根据看门狗定时唤醒时间定
  461.         {// 计数唤醒
  462.             NVIC_SystemReset();
  463.             return;
  464.         }
  466.         ADC_Module_Init();
  468.         adc_val = Get_Adc(0);
  469.         adc_val = adc_val*0.8056640625; // 测得电压
  470.         if( (adc_val > 800) // 检测到有电流，唤醒78
  471.             ||(SleepStruct.sleep_flag == 0)
  472.         )
  473.         {// 电压大于400 = 0.4v
  475.             NVIC_SystemReset();
  476.             return;
  477.         }
  479.     }
  481. }
  483. /*
  484. *休眠模式：停止模式（普通休眠）
  485. */
  486. void LowPower(void)
  487. {
  488.     uint8_t SaveInsertWdg;
  490.     if(GetSystemRunTimer()>10000)
  491.     {
  492.         Cap_SaveSocDat(); // 数据保存
  493.     }
  495.     BQ940_Power_Manage(BQ940_SLEEP_CMD); // 940关闭
  497. #if    INSERT_DOG_ENABLE 
  498.       WriteSleepFlag(SleepFlagValue);
  499.     SaveInsertWdg = SleepFlagValue;
  500.     SleepStruct.sleep_flag = 1;
  501. #endif 
  503.     Re_LowPower();
  504. }

STANDBY休眠模式

  1. /*
  2. * 深度休眠
  3. */
  4. void LowPower_SEEP(void)
  5. {
  6.     uint8_t SaveInsertWdg;
  7.     if(GetSystemRunTimer()>10000)
  8.     {
  9.         Cap_SaveSocDat(); // 数据保存
  10.     }
  12.   BQ940_Power_Manage(BQ940_SLEEP_CMD); // 关闭940
  14.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR , ENABLE);
  16. #if INSERT_DOG_ENABLE /*使用内部看门狗*/  
  18.     SaveInsertWdg = SleepFlagValue;
  20.     WriteLowPowerFlag(SaveInsertWdg);
  22. #endif 
  23.   PWR_WakeUpPinCmd(ENABLE);     /*使能WAKEUP脚唤醒*/ 
  24.   _Delay_Nms(500);
  26.   FeedWatchDog(); // 喂狗
  27.   NVIC_SystemReset(); // 复位
  28.   PWR_EnterSTANDBYMode();       /*进入待机模式*/
  29. }
  31. void Re_LowPower_SEEP(void)
  32. {
  33.   WriteLowPowerFlag(LowPowerFlagClear); // 清除进入休眠标志位
  35.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR , ENABLE);
  37.   PWR_WakeUpPinCmd(ENABLE);     /*使能WAKEUP脚唤醒*/
  38.   _Delay_Nms(100);
  39.   PWR_EnterSTANDBYMode();       /*进入待机模式*/
  40. }
  42. //休眠设置
  43. void InsertLowpowerInit(void)
  44. {
  45.     uint8_t ReadBackWatchdogFlag;
  46.     ReadBackWatchdogFlag = ReadLowPowerFlag(); // 获取进入休眠标志位
  48.     if (ReadBackWatchdogFlag == LowPowerFlagValue)
  49.     {// 进入深度休眠
  50.         EnableInterrupt(); /*硬件初始化完成后开总中断*/
  51.         Re_LowPower_SEEP();
  52.     }
  53.     else
  54.     {
  55.         WatchDog_Config(); 
  56.     }
  57. }