hicj6.c

这是一个

        if(Bat_Tmp)
        {
         Battery=Bat_Val[i];
        }
      }
     write7279(UNDECODE+5,0,1);
     write7279(UNDECODE+4,Battery,1);
     }
 }
}

/**********************************************************
*名	   称：Short_Pro
*功	   能：短路报警检测
*说	   明：
*调	   用：
*入口参数：无
*返 回 值：无
***********************************************************/
void Short_Pro(void)
{
 BYTE i,j,P1_Tmp;
for (i=0;i<5;i++)
    {
     P1_Tmp=1<<(i+3);
     P1_Tmp=~P1_Tmp&0xf8;
     for(j=0;j<8;j++)
      {
       if((Short_En[i]&(1<<j))!=0)
       {
       P1=P1_Tmp|A8_A10[j];
       long_delay();
       if (Short_Check==0)
             {
              Short_Bak=Read1B(170+i);
              Short_New[i]|=(1<<j);
              if(Short_New[i]^Short_Bak&Short_New[i])
                {
                Alarm_Flag=1;
                Short_Bak=Short_New[i];
                Write1B(Short_Bak,170+i);
                }

             }
             else
             {
              Short_New[i]&=~(1<<j);
             }
       }
      }
    }
}



/**********************************************************
*名	   称：Break_Check
*功	   能：断线报警检测
*说	   明：
*调	   用：
*入口参数：无
*返 回 值：无
***********************************************************/
void Break_Pro(void)
{

 BYTE i,j,P1_Tmp;
for (i=0;i<5;i++)
    {
     P1_Tmp=1<<(i+3);
     P1_Tmp=~P1_Tmp&0xf8;
     for(j=0;j<8;j++)
      {
        if((Break_En[i]&(1<<j))!=0)
         {
          if (Break_Check==0)
             {
              Break_Bak=Read1B(175+i);
              Break_New[i]|=(1<<j);
              if(Break_New[i]^Break_Bak&Break_New[i])
               {
                Break_Bak=Break_New[i];
                Write1B(Break_Bak,175+i);
               }

             }
             else
             {
              Break_New[i]&=~(1<<j);
             }
         }
      }
    }
}
/**********************************************************
*名	   称：Alarm_Pro
*功	   能：短路、断线报价处理
*说	   明：
*调	   用：
*入口参数：无
*返 回 值：无
***********************************************************/
void Alarm_Pro(void)
{
        BYTE i;
        Alarm_Check=0;
        Type=0;
        Alarm=0;
        Flash=0;
        for(i=0;i<5;i++)
         {
          Short_Bak=Read1B(170+i);
          Break_Bak=Read1B(175+i);
          if((Short_New[i]|Short_Bak)&Short_En[i]&Hdd_En[i])  Alarm|=0x10;
          if((Break_New[i]|Break_Bak)&Break_En[i]&Hdd_En[i])  Alarm|=0x20;
          if(Short_New[i]&Short_En[i]) Flash|=1;
          if(Break_New[i]&Break_En[i]) Flash|=2;
         }
         for(i=0;i<40;i++)
         {
          Type=Read1B(200+i);
          if((Hdd_En[i%8]&(1<<(i%8))))
           {
            if(Type&0x01)  Alarm|=0x04;
            if(Type&0x02)  Alarm|=0x02;
            if(Type&0x04)  Alarm|=0x01;
            if(Type&0x08)  Alarm|=0x80;
           }
         }
         Alarm_Flag=1;
}
/**********************************************************
*名	   称：TrsRelay
*功	   能：通过口线模拟的串口给控制器发送合分指令
*说	   明：
*调	   用：
*入口参数：无
*返 回 值：无
***********************************************************/

void TrsRelay(BYTE YkNo,BYTE YkHf)
  {
    BYTE Check;
    DIR2=0;
    long_delay();
    PSendChar(0xfe);
    PSendChar(0xeb);
    PSendChar(0x90);
    PSendChar(0x00);
    PSendChar(0x00);
    PSendChar(0x00);
    PSendChar(0x00);

    PSendChar(0x06); //Length
    PSendChar(0x00); //0
    PSendChar(0x37);//Function
    PSendChar(Relay_Station);//Station    L
    PSendChar(0x00);//0          H
    PSendChar(YkNo);
    PSendChar(YkHf);
    Check=YkNo+YkHf+0x37+Relay_Station;
    PSendChar(Check);
    DIR2=1;
  }

/**********************************************************
*名	   称：WriteHddPro
*功	   能：保存电度值
*说	   明：
*调	   用：
*入口参数：无
*返 回 值：无
***********************************************************/
void WriteHddPro(void)
{
   BYTE Constant_Range,Range,i,j;
   DWORD Full_L;
// Run=1;
      if(HddVal[WriteOrder])
       {
      
                Constant_Range=Read1B(120+i*8+j);
                switch (Constant_Range)
                  {
                    case (0x26):
                             Range=0;
                             break;
                    case (0x36):
                             Range=1;
                             break;
                    case (0x56):
                             Range=2;
                             break;
                    case (0x76):
                             Range=3;
                             break;
                    case (0x86):
                             Range=4;
                             break;                             
                    default:
                             Range=0;
                             break;
                  }
                Full_L=Full_Val[Range];
//                Full_L=320000000;
                Hdd_Str.Hdd_L=Read_Hdd(WriteOrder);
                Hdd_Str.Hdd_L+=HddVal[WriteOrder];
                if(Hdd_Str.Hdd_L>Full_L)
                 {
                  Hdd_Str.Hdd_L-=Full_L;
                 }
               
      
        
        HddVal[WriteOrder]=0;
        Write_Hdd(WriteOrder);
       }
      WriteOrder++;
      if(WriteOrder==40) WriteOrder=0;
//   Run=0;
}

/**********************************************************
*名	   称：Turn_On
*功	   能：长按键启动采集器
*说	   明：
*调	   用：
*入口参数：无
*返 回 值：无
***********************************************************/
void Turn_On(void)
{
        BYTE i;
        Key_Count=0;
        Speaker=0;
        delay10ms(100);
       for(i=0;i<5;i++)
        {
         Short_New[i]=0;
         Write1B(0,170+i);
         Break_New[i]=0;
         Write1B(0,175+i);
        }
        Speaker=1;
        Start=0x80;
        Write1B(0x80,255);
        Alarm_Flag=1;
}


/**********************************************************
*名	   称：OverRange
*功	   能：过负荷断电
*说	   明：
*调	   用：
*入口参数：无
*返 回 值：无
***********************************************************/
void OverRange(void)
{
     BYTE i,j,Tmp1;
     BYTE YkNo;
     if(ms500>9)
      {
       ms500=0;
       for(i=0;i<40;i++)
         {
         Tmp1=Read1B(200+i);
         if(Tmp1&0x80)
           {
            Tmp1&=0x7f;
            if(Hdd10s[i]>Tmp1)
             {
              RelayOff[i/8]|=1<<(i%8);
             }
             Hdd10s[i]=0;
           }
         }
      }

     if(Trs_Counter>50)
      {
        Trs_Counter=0;
        for(i=0;i<5;i++)
         {
          if(RelayOff[i])
            {
              for(j=0;j<8;j++)
                {
                    Tmp1=1<<j;
                  if(RelayOff[i]&Tmp1)
                    {
                      RelayOff[i]&=~Tmp1;
                      YkNo=i*8+j+1;
                      TrsRelay(YkNo,0x33);
                      TrsRelayOff[i]|=Tmp1;
                      i=5;
                      break;
                    }
                }
            }
         }



        for(i=0;i<5;i++)
           {
            if(TrsRelayOff[i])
              {
                for(j=0;j<8;j++)
                  {
                      Tmp1=1<<j;
                    if(TrsRelayOff[i]&Tmp1)
                      {
                       if(TrsOffCount[i*8+j]>240)      //2分钟
                         {
                          TrsOffCount[i*8+j]=0;
                          YkNo=i*8+j+1;
                          TrsRelayOff[i]&=~Tmp1;
                          TrsRelay(YkNo,0xcc);
                          i=5;
                          break;
                         }
                      }
                  }
              }
           }
      }



  for(i=0;i<5;i++)
   {
    if(TrsRelayOff[i])
     {
       for(j=0;j<8;j++)
        {
          Tmp1=1<<j;
          if(TrsRelayOff[i]&Tmp1)
          TrsOffCount[i*8+j]++;
        }
     }
   }


}


/**********************************************************
*名	   称：main
*功	   能：主程序
*说	   明：
*调	   用：
*入口参数：无
*返 回 值：无
***********************************************************/

 main()
{
    Init();

loop:

   if(Press_Count<3) Speaker=0;
     if(Press_Count==3 || Press_Count==4) Speaker=1;
     if(Time_Counter>Run_Count)
  {
         Time_Counter=0;
         ms500++;
   // TrsRelay(1,0xcc);    //////
        if(HddEn_Count)
      {
       HddEn_Count_Pro();
      }
     if(Run) Short_Pro();
       else  Break_Pro();
     WriteHddPro();
    if((Start&0x80)==0x80) Run_Count=25;
     else Run_Count=5;
     Run=~Run;
     //if(Run) TrsRelay(1,0x33);
     // else TrsRelay(1,0xcc);

    Bat_Check();
     if(Pulse)
     {
      Pulse=0;
      if(Run)write7279(SEGON,0x33,1);
        else
             write7279(SEGOFF,0x33,1);
     }

     if(Flash&0x01)
      {  if(Run)
         write7279(SEGON,0x34,1);
          else
          write7279(SEGOFF,0x34,1);
      }
     if(Flash&0x02)
      {  if(Run)
         write7279(SEGON,0x35,1);
          else
          write7279(SEGOFF,0x35,1);
      }




  }

    if (Press_Count<1000 && Sp_Flag)
    {
     Speaker=Run;

    }
    else
    Speaker=Key;

    if(((Start&0x80)==0x80) && (Hdd_Rp!=Hdd_Wp))
     Hdd_Check();
    if (Key_Press==1) Disp_Pro();

     if (Press_Count==1000)
      {
        Press_Count=1001;
        EA=0;
      	send_byte(CMD_RESET,0);				// 清除显示
        send_byte(CMD_RESET,1);
        cs1=cs2=1;
        EA=1;
        House=House_Max-1;
        Speaker=1;
        Alarm_Check=1;
       }

      if(Alarm_Check) Alarm_Pro();
      Key_Pro();
     if(Rcv_Flag)
      {
      	Rcv_Pro();
      }
     if(Trs_Flag==1 && Trs_Wp==Trs_Rp)
      {
      	Trs_Edit();
      }
      if(Rcv_Count>10) Rcv_Wp=0;
     if(Key_Count>100)  //长按键启动采集器
      {
       Turn_On();
      }


     if(Alarm_Flag)
       {
        Alarm_Flag=0;
        write7279(UNDECODE+6,Alarm,1);
       }

      OverRange();
  goto loop;

}