static.c

此源代码为电力系统中的RTU终端反馈!具有GPRS通讯功能!

 }
 
 if(Uabc.Ub<POFFVALUE)                         //B相停电时间      压小于30伏，认为停电
 {
    if(RunState.UbS!=0x3)          //上次不是停电
     {     
      if( ((RunState.UbS==0x1)||(RunState.UbS==0x2)))  //越限结束时间保存
        {
          LimitHand(2, FALSE,time,0) ;
          mode |=W_YC_LIMT;
        }
         PwOffHand(2, TRUE,time);          
         RunState.nBOffNums++; //停电次数         
                          
     }
      RunState.UbS=0x3; 
 }
 else
      if(DeviceState.Minutef1) RunState.BRunTime++;  
  clr_watchdog();     
 //C相
if((Uabc.Uc<=nhighV-ULIMIT)&&(Uabc.Uc>=nlowV+ULIMIT))//正常状态 
{
  if(RunState.UcS!=0x0)
  {

     if( RunState.UcS==0x1||RunState.UcS==0x2 )  //上次越限状态
     {  
          LimitHand(3, FALSE,time,0) ;
          mode |=W_YC_LIMT;      
     }
    if(RunState.UcS==0x3)                      //上次为停电状态
    { 
      PwOffHand(3, FALSE,time);
      mode |= W_POW_OFF;
    }
    
   }
    RunState.UcS=0;
}
 
 if((Uabc.Uc<nlowV)&&(Uabc.Uc>=POFFVALUE))//越下限  
 {
   if(RunState.UcS!=0x2)                  //上次状态不为越下限
   { 
    if(RunState.UcS==0x3)                      //上次为停电状态
    {
     PwOffHand(3, FALSE,time);
     mode |= W_POW_OFF;
    }
     if(RunState.UcS==0x1)                      //上次为越上限
     {
        LimitHand(3, FALSE,time,0) ;
        mode |=W_YC_LIMT;
     }
     clr_watchdog();  
     LimitHand(3, TRUE,time,2 ) ;    
           
   }
   RunState.UcS=0x2; 
        //C相电压日越下限时间
   if(DeviceState.Minutef1) RunState.UcDownSTime++;
 }
  
 if(Uabc.Uc>nhighV)                 //越上限
 {
   if(RunState.UcS!=0x1)                //上次不是越上限状态
   {
     if(RunState.UcS==0x3)                      //上次为停电状态
    {
     PwOffHand(3, FALSE,time);
     mode |= W_POW_OFF;
    }
    
     if(RunState.UcS==0x2)                      //上次为越下限
     {
        LimitHand(3, FALSE,time,0) ;
        mode |=W_YC_LIMT;
     }    
     LimitHand(3, TRUE,time,1 ) ;    
       
   }
   RunState.UcS=0x01;  
  //日越上限时间  
   if(DeviceState.Minutef1) RunState.UcUpSTime++;
 }
  clr_watchdog();     
 if(Uabc.Uc<POFFVALUE)                             //电压小于30伏，认为停电
 {
   if(RunState.UcS!=0x3)          //上次不是停电
     {
       if( ((RunState.UcS==0x1)||(RunState.UcS==0x2)))  //越限结束时间保存
        {
           LimitHand(3, FALSE,time,0) ; 
            mode |=W_YC_LIMT;
        }
         PwOffHand(3, TRUE,time);
       //停电次数
         RunState.nCOffNums++;
        
      }  
         RunState.UcS=0x3;  
 } 
 
 else
     if(DeviceState.Minutef1) RunState.CRunTime++;
   if(DeviceState.Minutef1)
   {   
      if((Uabc.Ua>=POFFVALUE) || (Uabc.Ub>=POFFVALUE) || (Uabc.Uc>=POFFVALUE) )
         RunState.SRunTime++;
      if((RunState.UaS==0x1) && ( RunState.UbS==0x1) && ( RunState.UcS==0x1))
         RunState.UsUpSTime++;
      if((RunState.UaS==0x2) && ( RunState.UbS==0x2) && ( RunState.UcS==0x2))
         RunState.UsDownSTime++;
     }
   if(DeviceState.doSavePowerOff)  
  { 
    RunState.nSOffNums++;
    WriteStaticsData(0xff);
    mode=0xff;
  }
//  else  
//  if(mode)  WriteStaticsData( mode );
  if(DeviceState.Minutef1)  DeviceState.Minutef1=0;
}


BOOL ReadStaticsData(BYTE *pdata,BYTE *len,STDATETIME *dayandtime,BYTE mode ,BYTE maxlen)
{
 if((dayandtime->month ==stDateTime.month )  && ((dayandtime->week_date & 0x1f) == (stDateTime.week_date & 0x1f)) )
 { 
  switch(mode)
   {
      case 11: 
            memcpy(pdata, (BYTE*)over_limit, 64);    //遥测越限纪录
            *len =64; 
            break;
      case 12:                                            
            memcpy(pdata, (BYTE*)value_time, 64);    //极值时间
            *len = 64; 
            break; 
      case 13:                                           //供电情况
           memcpy(pdata, (BYTE*)&RunState, sizeof(RTSTATE)); 
           *len = sizeof(RTSTATE); 
            break; 
      case 14:                                            //日停电纪录
           memcpy(pdata, (BYTE*)off_time, 54);       
           *len = 54; 
           break; 
      case 15:                                          //日结束电量
          
           Read1024(0,PVPOWERB,pdata,MAXDD*sizeof(long));  
           
          *len = MAXDD*sizeof(long); 
          break ;
      default:
           break ;                                           
   }               
   return TRUE;
 }
 
   ptr_1024 =Get1024Page(*dayandtime,1);
   if(ptr_1024==0) return  FALSE;
   if(ptr_1024==505) return FALSE; 
   if(ptr_1024>511) return FALSE;   
   Read1024(ptr_1024,PMONTH,pdata,2);
   if((pdata[0]!=(*dayandtime).month)||(pdata[1]!=((*dayandtime).week_date)& 0x1f))
   {
    (*len)=0;
    return FALSE;
   }

   switch(mode)
   {
      case 11: 
            Read1024(ptr_1024,PYCOVERLIMIT,pdata,64);//遥测越限纪录
            *len =64; 
            break;
      case 12:                                            
            Read1024(ptr_1024,PVALUE_TIME,pdata,64); //极值时间
            *len = 64; 
            break; 
      case 13:                                             //供电情况
           Read1024(ptr_1024,PRTSTATE,pdata,sizeof(RTSTATE));
           *len = sizeof(RTSTATE); 
            break; 
      case 14:                                            //日停电纪录
           Read1024(ptr_1024,PPOWER_SUPPLY_STATE,pdata,54);
           *len = 54; 
           break; 
      case 15:                                          //日结束电量
          Read1024(ptr_1024,PSUMOFPOWER,pdata,MAXDD*sizeof(long));
          *len = MAXDD*sizeof(long); 
          break ;
      default:
           break ;                                           
   }               
    return TRUE;   
 
}


void LimitHand(BYTE YCcode, BOOL begin, unsigned int time, BYTE LimitCode) 
{

if(begin)
{   
RunState.ValidRecords++;
if(RunState.ValidRecords>8) RunState.ValidRecords=8;
  if(YCcode==1)
   { 
      RunState.nACurUpRec=RunState.ValidRecords-1;
      over_limit[RunState.nACurUpRec].OverLimitValue=BD_data.Ua;
   }
   if(YCcode==2)
   {
     RunState.nBCurUpRec=RunState.ValidRecords-1;
     over_limit[RunState.nBCurUpRec].OverLimitValue=BD_data.Ub;
   }
    if(YCcode==3)
    {
      RunState.nCCurUpRec=RunState.ValidRecords-1;
      over_limit[RunState.nCCurUpRec].OverLimitValue=BD_data.Uc;
    }
  over_limit[RunState.ValidRecords-1].UpTimeStart=time; 
  over_limit[RunState.ValidRecords-1].YCcode=YCcode;   
  over_limit[RunState.ValidRecords-1].OverLimitCode=LimitCode;          //下限
  over_limit[RunState.ValidRecords-1].UpTimeEnd=0xFFFF; 

}
else
{
if(YCcode==1) 
   over_limit[RunState.nACurUpRec].UpTimeEnd=time; 
 if(YCcode==2) 
   over_limit[RunState.nBCurUpRec].UpTimeEnd=time;  
 if(YCcode==3) 
   over_limit[RunState.nCCurUpRec].UpTimeEnd=time;    
}

}


//停电记录处理
void PwOffHand(BYTE YCcode, BOOL begin, unsigned int time) 
{

if(begin)
{
  RunState.nOffRecords++;
  if(RunState.nOffRecords>9) RunState.nOffRecords=1;        //chengjin
  if(YCcode==1)
   { 
     RunState.nACurOffRec=RunState.nOffRecords-1;
   }
   if(YCcode==2)
   {
     RunState.nBCurOffRec=RunState.nOffRecords-1;
   }
    if(YCcode==3)
    {
      RunState.nCCurOffRec=RunState.nOffRecords-1;
    }
    if(YCcode==4)
    {
      RunState.nSCurOffRec=RunState.nOffRecords-1;
    }
    
   off_time[RunState.nOffRecords-1].DomainFlag=YCcode;
   off_time[RunState.nOffRecords-1].OffTimeStart=time;//停电起始时间   
   off_time[RunState.nOffRecords-1].OffTimeEnd=0xffff;
   off_time[RunState.nOffRecords-1].OffNum= RunState.nOffRecords;  
 }
 
else
  {
    if(YCcode==1) 
      off_time[RunState.nACurOffRec].OffTimeEnd=time;
    if(YCcode==2) 
      off_time[RunState.nBCurOffRec].OffTimeEnd=time;
    if(YCcode==3) 
      off_time[RunState.nCCurOffRec].OffTimeEnd=time; 
    if(YCcode==4) 
      off_time[RunState.nSCurOffRec].OffTimeEnd=time;      
  }
}

//清所有天的历史数据和统计数据
void  ClearAllData()
{

}

 //清当天的统计数据
void  ClearDayData()
{
  memset(&over_limit[0].OverLimitCode,0,8*sizeof(OverLimitData)); 
  memset(&off_time[0].DomainFlag,0,9*sizeof(OffTimeData));   
  memset((BYTE*)&RunState,0,sizeof(RTSTATE));     
  clr_watchdog();    
  change_value_time();    // 以当前的电压电流值作为极值的起始值
}

void change_value_time()  // 以当前的电压电流值作为极值的起始值
{
  BYTE  i;
  for(i=0;i<8;i++)
     {
       memcpy(&value_time[i].value,&BD_data.Ua+i,2);       //16 BYTES  
       value_time[i].time=stDateTime.hour;                 //小时
       value_time[i].time<<=8;
       value_time[i].time+=stDateTime.minute;              //分钟
     } 
     memcpy(&value_time[8].value,&BD_data.Ua,2);
     memcpy(&value_time[9].value,&BD_data.Ub,2);
     memcpy(&value_time[10].value,&BD_data.Uc,2);      
     for(i=0;i<3;i++)
     {
       value_time[8+i].time=stDateTime.hour;            //小时
       value_time[8+i].time<<=8;
       value_time[8+i].time+=stDateTime.minute;         //分钟
     } 
}