gy33485.c

红外抄表系统的源代码。利用非电信号传送控制信息和数据信息

              Ua_enable = 1;
         }
         PreUaIn = !Ua_in;

    }
    else    //Ua no fault processing
    {
         if(PreUaIn) //fault stop processing
         {
              Ua_interval_min = 0;
              for(i=2;i<6;i++)
                  FaultTime[i] = Curtime[i];  //fault start time(include month,date,hour,minute)
              FaultTime[1] = Curtime[0];
              FaultTime[0] = Ua;
              wr_s_eeprom(FaultTime,UaStartEeprom,sizeof(FaultTime));
              UaStartEeprom += 6;
              if(!Ua_enable) UaStartEeprom -= 12;
              else Ua_enable = 0;
         }
         Ua_fault_flag = 0;
         PreUaIn = !Ua_in;
    }
///////////////////////////////////////////////////////////////////
    Ub_in=1;
    if(!Ub_in)    //Ub fault processing
    {
         Ub_fault.sec=Ub_fault.sec+1;
         if(Ub_fault.sec>=60)
         {
              Ub_fault.sec = 0;
              Ub_fault.min++;

              if(Ub_fault.min>=60)
              {
                   Ub_fault.min = 0;
                   Ub_fault.hour++;
                   if(Ub_fault.hour>=10000)
                   {
                        Ub_fault.hour = 9999;
                   }
              }
         }
         wr_s_eeprom((uchar idata *)(&Ub_fault), Ub_EEPROM, sizeof(Ub_fault));
//----------------------------//
         if(UbStartEeprom > 314)
             UbStartEeprom = 200;
//----------------------------//
         if(!PreUbIn)
         {
              IntervalUbFlag = 1;
              // start Ub_fault  ,read start time,read Ub_fault.min
              Ub_start_min = Ub_fault.min;
              Ub_start_hour = Ub_fault.hour;
              for(i=2;i<6;i++)
                  FaultTime[i] = Curtime[i];  //fault start time(include month,date,hour,minute)
              FaultTime[1] = Curtime[0];
              FaultTime[0] = Ub;

              wr_s_eeprom(FaultTime,UbStartEeprom,sizeof(FaultTime));
              UbStartEeprom += 6;
          }
          if(IntervalUbFlag)
              Ub_interval_min = Ub_fault.min +(Ub_fault.hour-Ub_start_hour)*60 - Ub_start_min;
          if(Ub_interval_min >= 1)      //10
          {
              Ub_fault_flag = 1;
              IntervalUbFlag = 0;
              Ub_enable = 1;
          }
          PreUbIn = !Ub_in;
     }
     else
     {
          if(PreUbIn) //fault stop processing
          {
              Ub_interval_min = 0;
              for(i=2;i<6;i++)
                  FaultTime[i] = Curtime[i];  //fault start time(include month,date,hour,minute)
              FaultTime[1] = Curtime[0];
              FaultTime[0] = Ub;
              wr_s_eeprom(FaultTime,UbStartEeprom,sizeof(FaultTime));
              UbStartEeprom += 6;
              if(!Ub_enable) UbStartEeprom -= 12;
              else Ub_enable = 0;
          }
          Ub_fault_flag = 0;
          PreUbIn = !Ub_in;
    }
///////////////////////////////////////////////////////////////////
    Uc_in=1;
    if(!Uc_in)        //Uc fault processing
    {
         Uc_fault.sec=Uc_fault.sec+1;
         if(Uc_fault.sec>=60)
         {
              Uc_fault.sec = 0;
              Uc_fault.min++;

              if(Uc_fault.min>=60)
              {
                   Uc_fault.min = 0;
                   Uc_fault.hour++;
                   if(Uc_fault.hour>=10000)
                   {
                        Uc_fault.hour = 9999;
                   }
              }
         }
         wr_s_eeprom((uchar idata *)(&Uc_fault), Uc_EEPROM, sizeof(Uc_fault));
//----------------------------//

         if(UcStartEeprom > 434)
             UcStartEeprom = 320;
//----------------------------//
         if(!PreUcIn)
         {
              IntervalUcFlag = 1;
              // start Uc_fault  ,read start time,read Uc_fault.min
              Uc_start_min = Uc_fault.min;
              Uc_start_hour = Uc_fault.hour;
              for(i=2;i<6;i++)
                  FaultTime[i] = Curtime[i];  //fault start time(include month,date,hour,minute)
              FaultTime[1] = Curtime[0];
              FaultTime[0] = Uc;

              wr_s_eeprom(FaultTime,UcStartEeprom,sizeof(FaultTime));
              UcStartEeprom += 6;
          }
          if(IntervalUcFlag)
              Uc_interval_min = Uc_fault.min +(Uc_fault.hour-Uc_start_hour)*60 - Uc_start_min;
          if(Uc_interval_min >= 1)      //10
          {
              Uc_fault_flag = 1;
              IntervalUcFlag = 0;
              Uc_enable = 1;
          }
          PreUcIn = !Uc_in;
     }
     else
     {
         if(PreUcIn) //fault stop processing
         {
              Uc_interval_min = 0;
              for(i=2;i<6;i++)
                  FaultTime[i] = Curtime[i];  //fault start time(include month,date,hour,minute)
              FaultTime[1] = Curtime[0];
              FaultTime[0] = Uc;
              wr_s_eeprom(FaultTime,UcStartEeprom,sizeof(FaultTime));
              UcStartEeprom += 6;
              if(!Uc_enable) UcStartEeprom -= 12;
              else Uc_enable = 0;
          }
          Uc_fault_flag = 0;
          PreUcIn = !Uc_in;
    }
///////////////////////////////////////////////////////////////////
    Ia_in=1;
    if(!Ia_in)   //Ia fault processing
    {
         Ia_fault.sec=Ia_fault.sec+1;
         if(Ia_fault.sec>=60)
         {
              Ia_fault.sec = 0;
              Ia_fault.min++;
              if(Ia_fault.min>=60)
              {
                   Ia_fault.min = 0;
                   Ia_fault.hour++;
                   if(Ia_fault.hour>=10000)
                   {
                        Ia_fault.hour = 9999;
                   }
              }
          }
          wr_s_eeprom((uchar idata *)(&Ia_fault), Ia_EEPROM, sizeof(Ia_fault));
//----------------------------//
         if(IaStartEeprom > 554)
             IaStartEeprom = 440;
//----------------------------//
         if(!PreIaIn)
         {
             IntervalIaFlag = 1;
             // start Ia_fault  ,read start time,read Ia_fault.min
             Ia_start_min = Ia_fault.min;
             Ia_start_hour = Ia_fault.hour;

             for(i=2;i<6;i++)
                  FaultTime[i] = Curtime[i];  //fault start time(include month,date,hour,minute)
             FaultTime[1] = Curtime[0];
             FaultTime[0] = Ia;

             wr_s_eeprom(FaultTime,IaStartEeprom,sizeof(FaultTime));
             IaStartEeprom += 6;
         }
         if(IntervalIaFlag)
              Ia_interval_min = Ia_fault.min +(Ia_fault.hour-Ia_start_hour)*60 - Ia_start_min;
         if(Ia_interval_min >= 10)      //10
         {
              Ia_fault_flag = 1;
              IntervalIaFlag = 0;
              Ia_enable = 1;
         }
         PreIaIn = !Ia_in;
    }
    else    //Ua no fault processing
    {
         if(PreIaIn) //fault stop processing
         {
              Ia_interval_min = 0;
              for(i=2;i<6;i++)
                  FaultTime[i] = Curtime[i];  //fault start time(include month,date,hour,minute)
              FaultTime[1] = Curtime[0];
              FaultTime[0] = Ia;
              wr_s_eeprom(FaultTime,IaStartEeprom,sizeof(FaultTime));
              IaStartEeprom += 6;

              if(!Ia_enable) IaStartEeprom -= 12;
              else Ia_enable = 0;

         }
    	   Ia_fault_flag = 0;
    	   PreIaIn = !Ia_in;
    }
//////////////////////////////////////////////////////////////////////////
/*     Ib_in=1;
     if(!Ib_in)   //Ib fault processing  shiji
     {
             Ib_fault.sec=Ib_fault.sec+1;
             if(Ib_fault.sec>=60)
             {
                 Ib_fault.sec = 0;
                 Ib_fault.min++;

                 if(Ib_fault.min>=60)
                 {
                      Ib_fault.min = 0;
                      Ib_fault.hour++;
                      if(Ib_fault.hour>=10000)
                      {
                          Ib_fault.hour = 9999;
                      }
                 }
            }
            wr_s_eeprom((uchar idata *)(&Ib_fault), Ib_EEPROM, sizeof(Ib_fault));
	       if(!PreIbIn) //??????????
	       {
	       	   // start Ib_fault  ,read start time,read Ib_fault.min
	       	   Ib_start_min = Ib_fault.min;
	       	   IbDis5Start = 1;
             for(i=0;i<2;i++)
	       	       IbFault_start_time[i] = Curtime[i+4];  //fault start time(include month,date,hour,minute)
	       }
	       if(Ib_start_min > Ib_fault.min)
	           Ib_interval_min = Ib_fault.min + 60 - Ib_start_min;
	       else if(Ib_start_min < Ib_fault.min)
	       	   Ib_interval_min = Ib_fault.min - Ib_start_min;
	       if(Ib_interval_min >= 1)      //10
	       	   Ib_fault_flag = 1;
         PreIbIn = !Ib_in;

    }
    else    //Ib no fault processing
    {
    	   if(PreIbIn) //??????????fault stop processing
    	   	{
    	   		 // IbDis5Stop = 1;
    	   		  Ib_interval_min = 0;
    	   		  for(i=0;i<2;i++)
	       	       IbFault_stop_time[i] = Curtime[i+4];  //fault start time(include month,date,hour,minute)
    	   	}
    	   Ib_fault_flag = 0;
    	   PreIbIn = !Ib_in;//9999999999
    }*/
//////////////////////////////////////////////////////////////////////////
      Ic_in=1;
      if(!Ic_in)  //Ic fault processing
      {
         Ic_fault.sec=Ic_fault.sec+1;
         if(Ic_fault.sec>=60)
         {
              Ic_fault.sec = 0;
              Ic_fault.min++;
              if(Ic_fault.min>=60)
              {
                   Ic_fault.min = 0;
                   Ic_fault.hour++;
                   if(Ic_fault.hour>=10000)
                   {
                        Ic_fault.hour = 9999;
                   }
              }
         }
         wr_s_eeprom((uchar idata *)(&Ic_fault), Ic_EEPROM, sizeof(Ic_fault));
//----------------------------//
         if(IcStartEeprom > 674)
             IcStartEeprom = 560;
//----------------------------//
         if(!PreIcIn)
         {
             IntervalIcFlag = 1;
             // start Ic_fault  ,read start time,read Ic_fault.min
             Ic_start_min = Ic_fault.min;
             Ic_start_hour = Ic_fault.hour;
             for(i=2;i<6;i++)
                  FaultTime[i] = Curtime[i];  //fault start time(include month,date,hour,minute)
             FaultTime[1] = Curtime[0];
             FaultTime[0] = Ic;

             wr_s_eeprom(FaultTime,IcStartEeprom,sizeof(FaultTime));
             IcStartEeprom += 6;
         }
         if(IntervalIcFlag)
             Ic_interval_min = Ic_fault.min +(Ic_fault.hour-Ic_start_hour)*60 - Ic_start_min;
         if(Ic_interval_min >= 10)      //10
         {
             Ic_fault_flag = 1;
             IntervalIcFlag = 0;
             Ic_enable = 1;
         }
         PreIcIn = !Ic_in;
    }
    else    //Ic no fault processing
    {
         if(PreIcIn) //fault stop processing
         {
             Ic_interval_min = 0;
             for(i=2;i<6;i++)
                 FaultTime[i] = Curtime[i];  //fault start time(include month,date,hour,minute)
             FaultTime[1] = Curtime[0];
             FaultTime[0] = Ic;
             wr_s_eeprom(FaultTime,IcStartEeprom,sizeof(FaultTime));
             IcStartEeprom += 6;
             if(!Ic_enable) IcStartEeprom -= 12;
             else Ic_enable = 0;
         }
         Ic_fault_flag = 0;
         PreIcIn = !Ic_in;
    }
//==================================================
    Ip_in=1;
    if(Ip_in)  //Ip fault processing
    {
        if(Ua_in&Ub_in&Uc_in)
        {
             Ip_fault.sec=Ip_fault.sec+1;
             if(Ip_fault.sec>=60)
             {
                  Ip_fault.sec = 0;
                  Ip_fault.min++;
                  if(Ip_fault.min>=60)
                  {
                       Ip_fault.min = 0;
                       Ip_fault.hour++;
                       if(Ip_fault.hour>=10000)
                       {
                            Ip_fault.hour = 9999;
                       }
                  }
             }
             wr_s_eeprom((uchar idata *)(&Ip_fault), Ip_EEPROM, sizeof(Ip_fault));
//----------------------------//
         if(IpStartEeprom > 794)
             IpStartEeprom = 680;
//----------------------------//
             if(!PreIpIn)
             {
                  IntervalIpFlag = 1;
                  // start Ip_fault  ,read start time,read Ip_fault.min
                  Ip_start_min = Ip_fault.min;
                  Ip_start_hour = Ip_fault.hour;
                  for(i=2;i<6;i++)
                      FaultTime[i] = Curtime[i];  //fault start time(include month,date,hour,minute)
                  FaultTime[1] = Curtime[0];
                  FaultTime[0] = Ip;