/*
 * @Description: 云模块-svc层
 * @Author: yangsw
 * @Date: 2021-05-21 16:27:42
 * @LastEditTime: 2024-01-17 10:59:41
 * @LastEditors: LiDa
 * @Reference: 
 */

#include "svc_cloud.h"
#include "svc_cloud_protocol.h"
#include "param/svc/svc_flash.h"
#include "../../nb/svc/svc_nb_core.h"
#include "../../util/util_time.h"
#include "../../bat/svc/svc_bat.h"
#include "../../util/util_data.h"
#include "../../rtc/svc/svc_rtc.h"
#include "../../log/svc/svc_log.h"
#include "../../led/app/app_led.h"
#include "hci/led/app/sr_app_led.h"
S_Cloud s_cloud;
/**
 * @brief: 云模块初始化
 * @param  {void}
 * @return {void}
 * @note: 
 * @see: 
 */
void Svc_Cloud_Init(void){   
		S_Cloud_Data *ps_cloud; 
    #if LOG_FUNC_ENABLE  
		    Svc_Log_Printf(LOG_DEBUG,"%s \r\n",__FUNCTION__);
    #endif
    Svc_Cloud_Resend_Reset();
//    Svc_Cloud_Post_Event(E_Cloud_Event_Upload);
    Svc_Cloud_Protocol_Init();
		ps_cloud=Svc_Cloud_Get_Data();
		ps_cloud->u16FrameSerial=1;  
		ps_cloud->u8AesEnable =1;
}

/**
 * @brief: 云模块是否忙
 * @param  {void}
 * @return {E_Result_Check} E_CHECK_OK:忙，E_CHECK_FAIL:空闲
 * @note: 
 * @see: 
 */
E_Result_Check Svc_Cloud_Is_Busy(void){
    /*有待处理的事件或正在发送的事件时返回忙*/
    if((s_cloud.cloud_event!=0)||(s_cloud.e_cloud_sending_event!=E_Cloud_Event_No)){
        return E_CHECK_OK;
    }else{
        return E_CHECK_FAIL;
    }
}

/**
 * @brief: 云事件推送
 * @return {void}
 * @note: 
 * @see: 
 * @param {E_Cloud_Event} cloud_event 需要推送的事件
 */
void Svc_Cloud_Post_Event(E_Cloud_Event cloud_event){
    s_cloud.cloud_event|=cloud_event;
    //s_cloud.s_manage.rsp_fail_cnt=0;
    /*重置重发时间间隔*/
    //s_cloud.s_manage.send_time_cnt=CLOUD_RESEND_CYCLE;
		Svc_Nb_Faile_Reset();
    if(Svc_Com_Sys_Get_Work_Mode() == E_NormalMode)
    {
      if((SR_AppLedGetFlag() & 0x0b00)==0){
          SR_AppLedSetFlag(LED_NB_NET_INIT);
      }
    }
}

/**
 * @brief: 重置发送参数
 * @return {void}
 * @note: 
 * @see: 
 * @param 
 */
//void Svc_Cloud_Reset_Manage_Send_Time(void){
//    /*重置重发时间间隔*/
//    s_cloud.s_manage.send_time_cnt=CLOUD_RESEND_CYCLE;
//}

/**
 * @brief: 云事件清除
 * @return {void}
 * @note: 
 * @see: 
 * @param {E_Cloud_Event} cloud_event 需要清除的事件
 */
void Svc_Cloud_Clear_Event(E_Cloud_Event cloud_event){
    /*清除云事件*/
    s_cloud.cloud_event&=~cloud_event;
    /*清除正在发送的云事件*/
    s_cloud.e_cloud_sending_event=E_Cloud_Event_No;
    /*清除失败重发次数*/
    //s_cloud.s_manage.rsp_fail_cnt=0;
    /*清除发送计时*/
    //s_cloud.s_manage.send_time_cnt=0;
}

/**
 * @brief: 获取所有触发的事件
 * @param  {void}
 * @return {gw_u16}  所有触发的事件
 * @note: 
 * @see: 
 */
gw_u16 Svc_Cloud_Get_Event(void){
    return s_cloud.cloud_event;
}

/**
 * @brief: 获取正在进行的事件
 * @param  {void}
 * @return {gw_u16}  正在进行的事件
 * @note: 
 * @see: 
 */
gw_u16 Svc_Cloud_Get_Sending_Event(void){
    return s_cloud.e_cloud_sending_event;
}

/**
 * @brief: 获取处于等待处理的最高优先级事件
 * @param  {void}
 * @return {E_Cloud_Event}  处于等待处理的最高优先级事件
 * @note: 
 * @see: 
 */
E_Cloud_Event Svc_Cloud_Get_Pending_Event(void){    
    if((s_cloud.cloud_event&E_Cloud_Event_Upload)==E_Cloud_Event_Upload){
        return E_Cloud_Event_Upload;
    }
    if((s_cloud.cloud_event&E_Cloud_Event_Rsp_Set)==E_Cloud_Event_Rsp_Set){
        return E_Cloud_Event_Rsp_Set;
    }
    if((s_cloud.cloud_event&E_Cloud_Event_Rsp_Info)==E_Cloud_Event_Rsp_Info){
        return E_Cloud_Event_Rsp_Info;
    }
    if((s_cloud.cloud_event&E_Cloud_Event_Upload_Historical)==E_Cloud_Event_Upload_Historical){
        return E_Cloud_Event_Upload_Historical;
    }
    if((s_cloud.cloud_event&E_Cloud_Event_Rsp_Historical)==E_Cloud_Event_Rsp_Historical){
        return E_Cloud_Event_Rsp_Historical;
    }
    if((s_cloud.cloud_event&E_Cloud_Event_Req_Ota_Data)==E_Cloud_Event_Req_Ota_Data){
        return E_Cloud_Event_Req_Ota_Data;
    }
    if((s_cloud.cloud_event&E_Cloud_Event_Req_Ota_Data_Large)==E_Cloud_Event_Req_Ota_Data_Large){
        return E_Cloud_Event_Req_Ota_Data_Large;
    }
    return E_Cloud_Event_No;
}

/**
 * @brief: 锁定事件，该事件状态转为发送中
 * @return {void}
 * @note: 事件被锁定后，会触发该事件的数据上报，直到该事件解锁
 * @see: 
 * @param {E_Cloud_Event} cloud_event 待锁定的事件
 */
void Svc_Cloud_Lock_Event(E_Cloud_Event cloud_event){
    s_cloud.e_cloud_sending_event=cloud_event;
    //Svc_Bat_RunMode_Change(COMMUICATION_MODE);
}

/**
 * @brief: 解锁事件，正在发送中的事件转为待处理
 * @param  {void}
 * @return {void}
 * @note: 使用该函数后，事件依然存在，只不过转为待处理，有优先级更高的事件触发时可以调用该函数
 * @see: 
 */
void Svc_Cloud_Unlock_All_Event(void){
    /*正在发送的云事件回退到云事件中*/
    s_cloud.cloud_event|=s_cloud.e_cloud_sending_event;
    /*清除正在发送的云事件*/
    s_cloud.e_cloud_sending_event=E_Cloud_Event_No;
}

/**
 * @brief: 检查是否需要等待一定时间后重新上报
 * @param  {void}
 * @return {void}
 * @note: 
 * @see: 
 */
void Svc_Cloud_Resend_Check(void){
    S_Flash_Data *ps_flash;
		Svc_Log_Printf(LOG_DEBUG,"%s \r\n",__FUNCTION__);	
		ps_flash=Svc_Flash_Get_Data();     		      
		if(s_cloud.s_manage.resend_cnt<ps_flash->s_para.u8ResendTimes){
				s_cloud.s_manage.resend_time_cnt=ps_flash->s_para.u8ResendWaiteTime*60;       
	  }
    else
    {
      s_cloud.s_manage.resend_cnt = 0;
    }
}

/**
 * @brief: 清重新上报计数
 * @param  {void}
 * @return {void}
 * @note: 
 * @see: 
 */
void Svc_Cloud_Resend_Clear(void){        
    s_cloud.s_manage.resend_cnt=0;
    s_cloud.s_manage.resend_time_cnt=0; 
}

/**
 * @brief: 清重新上报计数
 * @param  {void}
 * @return {void}
 * @note: 
 * @see: 
 */
void Svc_Cloud_Resend_Reset(void){  
  S_Flash_Data *ps_flash;		
  ps_flash=Svc_Flash_Get_Data();	
  s_cloud.s_manage.resend_cnt=0;
  s_cloud.s_manage.resend_time_cnt=ps_flash->s_para.u8ResendWaiteTime*60; 
}

/**
 * @brief:检查事件是否改变 
 * @return {E_Result_Check} 检查结果
 * @note: 当待检查的事件和正在发送的事件不一致时，说明事件发生了变化，可能是优先级更高的事件插入
 * @see: 
 * @param {E_Cloud_Event} e_event 待检查的事件
 */
E_Result_Check Svc_Cloud_Event_Is_Changed(E_Cloud_Event e_event){
  if((s_cloud.e_cloud_sending_event==E_Cloud_Event_No)&& (s_cloud.e_cloud_sending_event!=e_event)){
      return E_CHECK_OK;
  }
  return E_CHECK_FAIL;
}

/**
 * @brief: 重发失败次数检查
 * @param  {void}
 * @return {E_Result_Check}
 * @note: 重发失败次数大于设置的重发失败次数时返回E_CHECK_FAIL
 * @see: 
 */
//E_Result_Check Svc_Cloud_Event_Fail_Check(void){
//    if(s_cloud.s_manage.rsp_fail_cnt>CLOUD_RESEND_TIMES){         //数据上报服务器失败            
//        return E_CHECK_FAIL;
//    }
//    return E_CHECK_OK;
//}

/**
 * @brief: 重发计时和保持网络连接计时
 * @param  {void}
 * @return {void}
 * @note: 
 * @see: 
 */
void Svc_Cloud_Timer_Callback(void){
    if(s_cloud.s_manage.u8KeepAliveTime>0){
        s_cloud.s_manage.u8KeepAliveTime--;
    }
    if(s_cloud.s_manage.resend_time_cnt>0){
        s_cloud.s_manage.resend_time_cnt--;
        if(s_cloud.s_manage.resend_time_cnt==0){   
            s_cloud.s_manage.resend_cnt++;
						Svc_Cloud_Post_Event(E_Cloud_Event_Upload);  
						Svc_Cloud_Resend_Check();
        }
    } 
}

/**
 * @brief: 检查是否需要上报数据
 * @param  {void}
 * @return {void}
 * @note: 周期上报检查
 * @see: 
 */
static void Cloud_Check_Upload_Data(void){   
		gw_u8   	*pu8CurTime;//年，月，日，时，分，秒
    gw_u8   	pu8TempTime[3];//时，分，秒
		gw_u32  	u32Temp;      
		gw_u32 		u32CurTimes;
		gw_u32  	u32UploadTime;	 
		gw_u32  	u32UploadCycle;
    gw_u32  	u32DiscreteStart;    
    gw_u32  	u32DiscreteMaxTime; 
	
		S_Flash_Data *ps_flash;
		S_Flash_Device_Para	*ps_device_para;
		S_Flash_Usage_Info  *ps_usage_info;
		S_Flash_Day_Usage 	*ps_day_usage;
		S_Flash_Device_Security	 *ps_device_security;
    S_Cloud_Data *ps_cloud_data;
		S_Cloud_Manage *ps_cloud_manage;
	
    ps_flash=Svc_Flash_Get_Data();
		ps_device_para=&ps_flash->s_para;
		u32UploadCycle=ps_device_para->u32ReportCycle;
		ps_device_security=&ps_flash->s_security;
    ps_usage_info = &ps_flash->s_usage_info; 
    ps_day_usage = &ps_usage_info->s_day_usage;				
		
		ps_cloud_data=Svc_Cloud_Get_Data();
		u32CurTimes=ps_cloud_data->u32CurTime;
    pu8CurTime=ps_cloud_data->pu8CurTime;
		ps_cloud_manage = &s_cloud.s_manage;
	    //防止校时后重报
    if(ps_cloud_data->u32CurTime < ps_cloud_data->u32LastTime){
        return;
    }
    if(u32UploadCycle==86400){ //按天上报86400
				u32DiscreteStart=(ps_device_para->u16ReportInterval/100)*60*60; 		//单位秒//起始上报时间
				u32DiscreteMaxTime=(ps_device_para->u16ReportInterval%100)*30*60;		//单位秒//上报区间的最大值
				u32Temp=Util_Data_Bcd_To_Decimal(ps_device_security->pu8MeterNum[5]);//获取表号的其中一位
				u32Temp=u32Temp*100;
				u32Temp=u32Temp+Util_Data_Bcd_To_Decimal(ps_device_security->pu8MeterNum[6]);//获取表号的另一位
				u32UploadTime=u32DiscreteStart+(ps_device_para->u8DiscreteStepTime*10*u32Temp)%u32DiscreteMaxTime;  //生成上报时间戳
				u32Temp=u32UploadTime;
				pu8TempTime[0]=u32Temp/3600%24;//时
				u32Temp=u32Temp%3600;
				pu8TempTime[1]=u32Temp/60;//分
				pu8TempTime[2]=u32Temp%60;//秒				
				if((pu8CurTime[3]==pu8TempTime[0])&&(pu8CurTime[4]==pu8TempTime[1])){//已到日上报时间
						if(ps_usage_info->u8NbReportFlag){
								ps_usage_info->u8NbReportFlag=0;
								Svc_Cloud_Resend_Reset();
								Svc_Cloud_Post_Event(E_Cloud_Event_Upload);
						}           
				}
				else{
						ps_usage_info->u8NbReportFlag=1;                
				}		
    }
    else if((u32UploadCycle<86400)&&(u32UploadCycle>=900)){//上报周期小于24小时，按照上报周期上报 
				u32UploadTime=ps_cloud_manage->u32LastUploadTime+u32UploadCycle;
				if(u32UploadTime<=u32CurTimes){
					Svc_Cloud_Resend_Reset();
					Svc_Cloud_Post_Event(E_Cloud_Event_Upload);     					
					ps_day_usage->s_usage_alarm=ps_usage_info->s_usage_alarm;                        
					memset(&ps_usage_info->s_usage_alarm,0,sizeof(S_Flash_Usage_Alarm));	
					if((u32UploadTime+u32UploadCycle)<=u32CurTimes){//慢了二个上报周期以上
                ps_cloud_manage->u32LastUploadTime=u32CurTimes;//上一次周期上报时间更新为当前时间
          }else{
                ps_cloud_manage->u32LastUploadTime=u32UploadTime;
          } 
				}             
    }
		else if(u32UploadCycle==0){//上报周期小于24小时，按照上报周期上报 
				u32UploadTime=ps_cloud_manage->u32LastUploadTime+300;
				if(u32UploadTime<=u32CurTimes){
					Svc_Cloud_Resend_Reset();
					Svc_Cloud_Post_Event(E_Cloud_Event_Upload);     					
					ps_day_usage->s_usage_alarm=ps_usage_info->s_usage_alarm;                        
					memset(&ps_usage_info->s_usage_alarm,0,sizeof(S_Flash_Usage_Alarm));
					if((u32UploadTime+300)<=u32CurTimes){//慢了二个上报周期以上
                ps_cloud_manage->u32LastUploadTime=u32CurTimes;//上一次周期上报时间更新为当前时间
            }else{
                ps_cloud_manage->u32LastUploadTime=u32UploadTime;
          } 
				}             
    }
		else{
				Svc_Log_Printf(LOG_INFO,"Error out range  u32UploadCycle = %d \r\n",u32UploadCycle);
		}
}

/**
 * @brief: 时间校准
 * @return {void}
 * @note: 
 * @see: 
 * @param {gw_u32} 时间戳，自2000-1-1日起
 */
void Svc_Cloud_Time_Calibrate(gw_u32 u32Time){
    
    gw_u8 				pu8Time[6];
		gw_u16       	u16BatVol;
    S_Flash_Data *ps_flash;
    S_Cloud_Data *ps_cloud_data;
    ps_cloud_data=Svc_Cloud_Get_Data();
    ps_flash=Svc_Flash_Get_Data();
		//更新上次与历史上报时间
    Util_Time_Timestamp_To_Time(u32Time,pu8Time);//时间戳转为日历
    if(pu8Time[0] < 23){//防止入网成功后系统下发时间为0，测试时候有发现类似问题 lida add code
        return;
    }
    if((ps_cloud_data->u32LastTime>=(u32Time+90*24*3600))||
        (u32Time>=(ps_cloud_data->u32LastTime+90*24*3600))){ //超过90天，表内时间与当前时间相差超过90天，系统刚上电会进入该处，进行一些列初始化动作。
				u16BatVol = ps_flash->s_usage_info.s_day_usage.s_real_usage.u16BatVol;
				//更新报警信息
        memset(&ps_flash->s_usage_info.s_usage_alarm,0,sizeof(S_Flash_Usage_Alarm));
        //更新日冻结信息
        memset(&ps_flash->s_usage_info.s_day_usage,0,sizeof(S_Flash_Day_Usage));  
				memcpy(ps_flash->s_usage_info.s_day_usage.u8StartTime,pu8Time,6);
				memcpy(ps_flash->s_usage_info.s_day_usage.s_real_usage.u8MaxUseTime,pu8Time,6);
				memcpy(ps_flash->s_usage_info.s_day_usage.s_real_usage.u8InfoTime,pu8Time,6);					
				ps_flash->s_usage_info.s_day_usage.s_real_usage.u32TotalUsageNegMidnight=ps_flash->s_usage_info.u32TotalUsageNeg;
        ps_flash->s_usage_info.s_day_usage.s_real_usage.u32TotalUsagePosMidnight=ps_flash->s_usage_info.u32TotalUsagePos;
				ps_flash->s_usage_info.s_day_usage.s_real_usage.u32TotalUsage=ps_flash->s_usage_info.u32TotalUsage;						
				ps_flash->s_usage_info.s_day_usage.s_hour_usage.u8RecordNumb =	((gw_u16)pu8Time[3]*60+pu8Time[4])/30;	
				ps_flash->s_usage_info.s_day_usage.s_real_usage.u16BatVol = u16BatVol;
        pu8Time[3]=0;
        pu8Time[4]=0;
        pu8Time[5]=0;
        memcpy(ps_flash->s_usage_info.u8LastUpdataTime,pu8Time,6);
        memcpy(ps_flash->s_usage_info.u8LastHistoryUpdataTime,pu8Time,6);       							
        //更新系统时间
        // Bsp_Com_Dis_Interrupts();//关中断
        //Bsp_Com_Dis_Interrupts();
				ps_cloud_data->u32SystemTime=u32Time;  //该处通过NB基站时间来校准单片机系统时间
				ps_cloud_data->u32LastSystemTime=u32Time; //该处通过NB基站时间来校准单片机系统时间
				Svc_Rtc_Set_Time_Flash();
        //Bsp_Com_En_Interrupts();
        //Bsp_Com_En_Interrupts();
    }
    else if(ps_cloud_data->u32LastTime<u32Time){//正走

        if((ps_cloud_data->u32LastTime/(24*3600))!=(u32Time/(24*3600))){//跨天
            if(ps_flash->s_usage_info.s_day_usage.u8DaySaveFlag == 0)
            {
                return;
            }
            //更新报警信息
            ps_flash->s_usage_info.s_day_usage.s_usage_alarm=ps_flash->s_usage_info.s_usage_alarm;          
            memset(&ps_flash->s_usage_info.s_usage_alarm,0,sizeof(S_Flash_Usage_Alarm));
					  Svc_Flash_Check_Save_30Min_Usage_Time_Calibrate(ps_cloud_data->u32LastTime,u32Time); //更新小时用量						
            //保存当日数据						
            Svc_Flash_Write_Day_Usage(&ps_flash->s_usage_info.s_day_usage);
            //更新日冻结信息 					
						u16BatVol = ps_flash->s_usage_info.s_day_usage.s_real_usage.u16BatVol;
						memset(&ps_flash->s_usage_info.s_day_usage,0,sizeof(S_Flash_Day_Usage));
						ps_flash->s_usage_info.s_day_usage.s_hour_usage.u8RecordNumb =	((gw_u16)pu8Time[3]*60+pu8Time[4])/30;	
						if(ps_flash->s_usage_info.s_day_usage.s_hour_usage.u8RecordNumb > 48){
								ps_flash->s_usage_info.s_day_usage.s_hour_usage.u8RecordNumb = 48;
						}
						pu8Time[3]=0;
						pu8Time[4]=0;
						pu8Time[5]=0;
						memcpy(ps_flash->s_usage_info.s_day_usage.u8StartTime,pu8Time,6);	
						memcpy(ps_flash->s_usage_info.s_day_usage.s_real_usage.u8MaxUseTime,pu8Time,6);
						memcpy(ps_flash->s_usage_info.s_day_usage.s_real_usage.u8InfoTime,pu8Time,6);
						ps_flash->s_usage_info.s_day_usage.s_real_usage.u32TotalUsageNegMidnight=ps_flash->s_usage_info.u32TotalUsageNeg;
						ps_flash->s_usage_info.s_day_usage.s_real_usage.u32TotalUsagePosMidnight=ps_flash->s_usage_info.u32TotalUsagePos;
						ps_flash->s_usage_info.s_day_usage.s_real_usage.u32TotalUsage=ps_flash->s_usage_info.u32TotalUsage;
						ps_flash->s_usage_info.s_day_usage.s_real_usage.u16BatVol = u16BatVol;
            ps_flash->s_usage_info.s_day_usage.u8DaySaveFlag = 0;//lida add code  为了防止重复存储天用量信息
          
        }else{ //少于一天                 
            //更新时间导致错过密集流量开始时间 	暂不处理
            //更新时间报警部分没有填充 					暂不处理
            //更新时间导致流量出错 							暂不处理
						Svc_Flash_Check_Save_30Min_Usage_Time_Calibrate(ps_cloud_data->u32LastTime,u32Time); //更新小时用量
        }
        //更新系统时间
        //disableInterrupts();  //关中断
        //Bsp_Com_Dis_Interrupts();            
				ps_cloud_data->u32SystemTime=u32Time;			
				ps_cloud_data->u32LastSystemTime=u32Time;	
				Svc_Rtc_Set_Time_Flash();
        //Bsp_Com_En_Interrupts();
        // enableInterrupts();       
    }else { //反走少于90天    
        //disableInterrupts();    //关中断    
        //Bsp_Com_Dis_Interrupts();           			
				ps_cloud_data->u32SystemTime=u32Time;
				Svc_Rtc_Set_Time_Flash();
        //Bsp_Com_En_Interrupts();
        //enableInterrupts(); 
    }
    Svc_Cloud_Refresh_Time();
	  Svc_Cloud_SysTime_Printf();
    Svc_Flash_Write_Usage(&ps_flash->s_usage_info);   
    Svc_Cloud_Time_Set_Calibrate();//设置为时间已校准
    
}

/**
 * @brief: 设置时间校准标志
 * @param  {void}
 * @return {void}
 * @note: 
 * @see: 
 */
void Svc_Cloud_Time_Set_Calibrate(void){
		S_Flash_Data *ps_flash; 
		S_Flash_Device_Security  *ps_security;
    ps_flash=Svc_Flash_Get_Data();  
		ps_security = &ps_flash->s_security;	
		if(Svc_Cloud_Time_Is_Calibrate()==0){//时间未校准的情况下
        ps_security->time_calibrate_flag=1;
				Svc_Flash_Write_Device_Security(&ps_flash->s_security);
    }
   
}

/**
 * @brief: 时间是否已校准
 * @param  {void}
 * @return {gw_u8} 1：已校准，0：未校准
 * @note: 
 * @see: 
 */
gw_u8 Svc_Cloud_Time_Is_Calibrate(void){
	
		S_Flash_Data *ps_flash; 
		S_Flash_Device_Security  *ps_security;
    ps_flash=Svc_Flash_Get_Data();  
		ps_security = &ps_flash->s_security;	
    return ps_security->time_calibrate_flag;
}
/**
 * @brief: 检查定时事件
 * @param  {void}
 * @return {void}
 * @note: 
 * @see: 
 */
void Svc_Cloud_Check_Timing_Event(void){
		//Svc_Log_Printf(LOG_DEBUG,"%s \r\n",__FUNCTION__);	
    if(Svc_Cloud_Time_Is_Calibrate()==0){//时间未校准的情况下不存储
        return;
    }    
    /*小时用量存储检查*/		
    Svc_Flash_Check_Save_30Min_Usage();
		// Svc_Wdg_Feed(0);	
    Bsp_Iwdg_Feed();
    /*日用量存储检查*/
    Svc_Flash_Check_Save_Day_Usage();
		// Svc_Wdg_Feed(0);	
    Bsp_Iwdg_Feed();
		/*密集流量存储检查*/
    Svc_Flash_Check_Save_Dense_Usage();		
		// Svc_Wdg_Feed(0);	
    Bsp_Iwdg_Feed();
    /*用量信息存储检查*/
    Svc_Flash_Check_Save_Usage();
		// Svc_Wdg_Feed(0);
    Bsp_Iwdg_Feed();	
    /*周期上报检查*/
    Cloud_Check_Upload_Data();
    Bsp_Iwdg_Feed();	
		// Svc_Wdg_Feed(0);	
}

/**
 * @brief: 设置保持网络连接时间
 * @return {void}
 * @note: 超时后进入休眠
 * @see: 
 * @param {gw_u8} u8Time 保持网络连接时间
 */
void Svc_Cloud_Set_Keep_Alive_Time(gw_u8 u8Time){
    s_cloud.s_manage.u8KeepAliveTime=u8Time;
}

/**
 * @brief: 等待下发命令
 * @param  {void}
 * @return {gw_u8} 剩余等待时间
 * @note: 
 * @see: 
 */
gw_u8 Svc_Cloud_Wait_Cmd(void){
    return s_cloud.s_manage.u8KeepAliveTime;
}

/**
 * @brief: Pulse用量信息打印
 * @return {void}
 * @note:
 * @see:
 * @param
 */
void Svc_Cloud_Event_Info_Printf(void)
{
    Svc_Log_Printf(LOG_INFO, "s_cloud.s_manage.u8KeepAliveTime = %d \r\n", s_cloud.s_manage.u8KeepAliveTime);    
    Svc_Log_Printf(LOG_INFO, "s_cloud.s_manage.resend_cnt= %d,s_cloud.s_manage.resend_time_cnt = %d \r\n", s_cloud.s_manage.resend_cnt,s_cloud.s_manage.resend_time_cnt);
    Svc_Log_Printf(LOG_INFO, "s_cloud.cloud_event = 0x%04x \r\n", s_cloud.cloud_event);                                   // 打印
    Svc_Log_Printf(LOG_INFO, "s_cloud.e_cloud_sending_event = 0x%04x \r\n", s_cloud.e_cloud_sending_event);               // 打印总流量
}