gy33485.c

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

}
//////////////////////////////////////////////////
//**********************eeprom stop******************************//
void DisStartT(uchar id,uint Eeprom)
{
     IdNum = id;
     a_start = 1;
     a_stop = 0;
     rd_s_eeprom(FaultTime,Eeprom,sizeof(FaultTime));
     switch(Key3Num)
     {
          case 1:
          case 2:
          case 3:
               DispIC1_start_stop(S1,FaultTime);
          break;
          case 4:
          case 5:
               DispIC1_start_stop(S2,FaultTime);
          break;
          case 6:
               DispIC1_start_stop(S3,FaultTime);
          break;
      }
}
void DisStopT(uchar id,uint Eeprom)
{
     IdNum = id;
     a_start = 0;
     a_stop = 1;
     rd_s_eeprom(FaultTime,Eeprom,sizeof(FaultTime));
     switch(Key3Num)
     {
          case 1:
          case 2:
          case 3:
               DispIC1_start_stop(S1,FaultTime);
          break;
          case 4:
          case 5:
               DispIC1_start_stop(S2,FaultTime);
          break;
          case 6:
               DispIC1_start_stop(S3,FaultTime);
          break;
      }
}
uchar Key2(void)
{
   uchar flag=0;
   if(P3_5==0)
        flag=1;
   else flag=0;
   return(flag);
}
uchar Key3(void)
{
   uchar flag=0;
   if(P2_4==0)
        flag=1;
   else flag=0;
   return(flag);
}

void main()
{
     uchar idata warning_flag;
     int  i;
     uchar  disp_buf[6];
     uchar msec;

     uchar num1 = 0;//5-23 added
     uchar num2 = 0;//5-25 added
     uchar num3 = 0;//5-25 added
     uchar num4 = 0;//5-25 added
     uchar num5 = 0;//5-25 added
     uchar num6 = 0;//5-25 added
     InitSci();//设置2400波特率，用来产生载波的定时器T0初值//



     P2_5 = 0;
     fbase = 0;
     prefbase = 0;
     disnum_flag = 0;

     rd_s_eeprom(disp_buf, EMPTY_EEPROM, 6);
     warning_flag = 0;
     for(i=0;i<6;i++)
     {
        if(disp_buf[i]!='A') warning_flag++;
     }
     if(warning_flag)      //initialize eeprom value
     {
        for(i=0;i<6;i++)  disp_buf[i]='A';
        wr_s_eeprom(disp_buf, EMPTY_EEPROM, 6);
        for(i=0;i<sizeof(Ua_fault);i++)  disp_buf[i]=0;
        wr_s_eeprom(disp_buf, Ua_EEPROM, sizeof(Ua_fault));
        wr_s_eeprom(disp_buf, Ub_EEPROM, sizeof(Ua_fault));
        wr_s_eeprom(disp_buf, Uc_EEPROM, sizeof(Ua_fault));
        wr_s_eeprom(disp_buf, Ia_EEPROM, sizeof(Ua_fault));
        wr_s_eeprom(disp_buf, Ib_EEPROM, sizeof(Ua_fault));
        wr_s_eeprom(disp_buf, Ic_EEPROM, sizeof(Ua_fault));
        wr_s_eeprom(disp_buf, Ip_EEPROM, sizeof(Ua_fault));
        wr_s_eeprom(disp_buf, UX_EEPROM, sizeof(Ua_fault));

        wr_s_eeprom(disp_buf, Num_EEPROM, sizeof(disnum[0]));//initialize all fault times

        for(i=0;i<20;i++)
        {
            wr_s_eeprom(disp_buf, UaStartEeprom, sizeof(FaultTime));//initialize all fault times
            UaStartEeprom += 6;
        }
        for(i=0;i<20;i++)
        {
            wr_s_eeprom(disp_buf, UbStartEeprom, sizeof(FaultTime));//initialize all fault times
            UbStartEeprom += 6;
        }
        for(i=0;i<20;i++)
        {
            wr_s_eeprom(disp_buf, UcStartEeprom, sizeof(FaultTime));//initialize all fault times
            UcStartEeprom += 6;
        }
        for(i=0;i<20;i++)
        {
            wr_s_eeprom(disp_buf, IaStartEeprom, sizeof(FaultTime));//initialize all fault times
            IaStartEeprom += 6;
        }
        for(i=0;i<20;i++)
        {
            wr_s_eeprom(disp_buf, IcStartEeprom, sizeof(FaultTime));//initialize all fault times
            IcStartEeprom += 6;
        }
        for(i=0;i<20;i++)
        {
            wr_s_eeprom(disp_buf, IpStartEeprom, sizeof(FaultTime));//initialize all fault times
            IpStartEeprom += 6;
        }
     }
     rd_s_eeprom((uchar *)(&Ua_fault), Ua_EEPROM, sizeof(Ua_fault));
     rd_s_eeprom((uchar *)(&Ub_fault), Ub_EEPROM, sizeof(Ub_fault));
     rd_s_eeprom((uchar *)(&Uc_fault), Uc_EEPROM, sizeof(Uc_fault));

     rd_s_eeprom((uchar *)(&Ia_fault), Ia_EEPROM, sizeof(Ia_fault));
     rd_s_eeprom((uchar *)(&Ib_fault), Ib_EEPROM, sizeof(Ib_fault));
     rd_s_eeprom((uchar *)(&Ic_fault), Ic_EEPROM, sizeof(Ic_fault));
     rd_s_eeprom((uchar *)(&Ip_fault), Ip_EEPROM, sizeof(Ip_fault));
     rd_s_eeprom((uchar *)(&UX_fault), UX_EEPROM, sizeof(UX_fault));

     rd_s_eeprom(disnum, Num_EEPROM, sizeof(disnum[0]));  //read all fault times

     rd_s_eeprom(disnum+1, 66, sizeof(disnum[1]));  //read each fault times
     if(disnum[1]&&!UaIflag)
     {
          UaStartEeprom += disnum[1]*12;
          UaIflag = 1;
     }
     rd_s_eeprom(disnum+2, 67, sizeof(disnum[2]));  //read each fault times
     if(disnum[2]&&!UbIflag)
     {
          UbStartEeprom += disnum[2]*12;
          UbIflag = 1;
     }
     rd_s_eeprom(disnum+3, 68, sizeof(disnum[3]));  //read each fault times
     if(disnum[3]&&!UcIflag)
     {
          UcStartEeprom += disnum[3]*12;
          UcIflag = 1;
     }
     rd_s_eeprom(disnum+4, 69, sizeof(disnum[4]));  //read each fault times
     if(disnum[4]&&!IaIflag)
     {
          IaStartEeprom += disnum[4]*12;
          IaIflag = 1;
     }
     rd_s_eeprom(disnum+6, 70, sizeof(disnum[6]));  //read each fault times
     if(disnum[6]&&!IcIflag)
     {
          IcStartEeprom += disnum[6]*12;
          IcIflag = 1;
     }
     rd_s_eeprom(disnum+7, 71, sizeof(disnum[7]));  //read each fault times
     if(disnum[7]&&!IpIflag)
     {
          IpStartEeprom += disnum[7]*12;
          IpIflag = 1;
     }


     beep = 1;
     clrbit = 1;


     /*InitTimer0();*///5_17 shaded
    InitTimer2();//5_17 shaded
     //InitSci();//设置2400波特率，用来产生载波的定时器T0初值//
     warning_flag = 0;

     /////////LCD///////////////
     LCD_Reset(0x01);   //reset LCD_IC1
     LCD_Reset(0x02);   //reset LCD_IC2
     Init_IC1();        //initialize LCD_IC1
     Init_IC2();        //initialize LCD_IC2

     Set1302(Curtime);
     W1302(0x90,0x0A5); //enable charge 1302 connected
     Curtime[6] = R1302(0x81);
     Curtime[6] = hex_to_dec(Curtime[6]);
    // rd_s_eeprom(FaultTime,200,sizeof(FaultTime));
     //FaultTime[6];

     while(1)     //for test
     {        Change_phase();
              SciSend();
              if(SpIntval==0) TotalNumOfTrb(disnum[0]);

              KickDog();
              msec = R1302(0x81);
              msec = hex_to_dec(msec);
              if(Curtime[6] != msec)
              {
                   Curtime[6] = msec;
                   mail_box_flag = 1;
              }
              loop();

              if(mail_box_flag)
              {
                  //xx();       //clear all fault_flag
                  gzsmdy();   //find fault and add fault_time
                  faultcount();
              }
              ///////////////////////////////////////////
              if(Key3())
              {
              	   P2_5 = 1;
              	  // TR0 = 0;
                    TR2 = 0;
              	   delay(1000);
                   while(Key3()) KickDog();
                   Key3Num %= 6;
                   Key3Num ++;
                   a_start = 0;
                   a_stop = 0;
                   IdNum = 0;
                   switch(Key3Num)
                   {
                       case 1:
                       	    TotalNumOfTrb(disnum[1]);
                       	    Phase_select(Phase_A);
                            DispIC1(S1,Ua_fault);
                            num1 = 0;
                       break;
                       case 2:
                       	    TotalNumOfTrb(disnum[2]);
                            Phase_select(Phase_B);
                            DispIC1(S1,Ub_fault);
                            num2 = 0;
                       break;
                       case 3:
                       	    TotalNumOfTrb(disnum[3]);
                            Phase_select(Phase_C);
                            DispIC1(S1,Uc_fault);
                            num3 = 0;
                       break;
                       case 4:
                       	    TotalNumOfTrb(disnum[4]);
                            Phase_select(Phase_A);
                            DispIC1(S2,Ia_fault);
                            num4 = 0;
                       break;
                       case 5:
                       	    TotalNumOfTrb(disnum[6]);
                            Phase_select(Phase_C);
                            DispIC1(S2,Ic_fault);
                            num5 = 0;
                       break;
                       case 6:
                       	    TotalNumOfTrb(disnum[7]);
                            LCD_WD2(26,0x08);           //no display A,B,C
                            DispIC1(S3,Ip_fault);
                            num6 = 0;
                       break;
                       default:
                       break;
                   }
                   SpIntval = 100;
                   //TR0 = 1;/修改
                   TR2=1;
               }
               ////////////////////////////////////////////
               if(Key2())
               {
               	   ResetNum = 0;//显示"第X次故障"
                   delay(1000);
                   while(Key2()) KickDog();
                   switch(Key3Num)
                   {
                       case 1:  //for Ua
                       	    Phase_select(Phase_A);
                       	    num1 %= 20;
                       	    num1++;
                       	    switch(num1)
                       	    {
                                 case 1:
                                      DisStartT(1,80);
                                 break;
                                 case 2:
                                      DisStopT(1,86);
                                 break;
                                 case 3:
                                      DisStartT(2,92);
                                 break;
                                 case 4:
                                      DisStopT(2,98);
                                 break;
                                 case 5:
                                      DisStartT(3,104);
                                 break;
                                 case 6:
                                      DisStopT(3,110);
                                 break;
                                 case 7:
                                      DisStartT(4,116);
                                 break;
                                 case 8:
                                      DisStopT(4,122);
                                 break;
                                 case 9:
                                      DisStartT(5,128);
                                 break;
                                 case 10:
                                      DisStopT(5,134);
                                 break;
                                 case 11:
                                      DisStartT(6,140);
                                 break;
                                 case 12:
                                      DisStopT(6,146);
                                 break;
                                 case 13:
                                      DisStartT(7,152);
                                 break;
                                 case 14:
                                      DisStopT(7,158);
                                 break;
                                 case 15:
                                      DisStartT(8,164);
                                 break;
                                 case 16:
                                      DisStopT(8,170);
                                 break;
                                 case 17:
                                      DisStartT(9,176);
                                 break;
                                 case 18:
                                      DisStopT(9,182);
                                 break;
                                 case 19:
                                      DisStartT(0,188);
                                 break;
                                 case 20:
                                      DisStopT(0,194);
                                 break;

                            }
                       break;
                       case 2:  //for Ub
                       	    Phase_select(Phase_B);
                       	    num2 %= 20;
                       	    num2++;
                       	    switch(num2)
                       	    {
                                 case 1: