xjdcf5.cpp

这是一个在正实际应用当中运行的电力监控系统软件源代码

    else if (func<0xd9)  //批次信息
     { Add = 6;     }
    else if (func<0xdf)  //备用
     { Add = 6;     }
    else if (func<0xe0)  //RTU运行状态
     { Add = 6;     }
    else if (func<0xe3)  //遥控
     { Add = Pyk(rdp);     }
    else if (func<0xe6)  //备用
     { Add = 6;     }
    else if (func<0xe9)  //设点
     { Add = 6;     }
    else if (func<0xec)  //升/降命令
     { Add = Psj(rdp);     }
    else if (func<0xf8)  //备用
     { Add = 6;     }
    else                //遥信
	 { Add = Pyx(rdp);   }
  return(Add);
}

BYTE Pyc(WORD rdp)
{
 BYTE FAR *rxb = lpChP->RecBuff;
 int ycOrd = (*(rxb+rdp)-1)*2;
 int ycValue = *(rxb+(rdp+2)%rxbuflen) + (*(rxb+(rdp+1)%rxbuflen))*256;
 if (ycOrd<64) SetValue(YCDB, lpChP->StaNo, ycOrd, ycValue);
 else SetValue(YCDB, lpChP->StaNo+1, ycOrd-64, ycValue);
 ycValue = *(rxb+(rdp+4)%rxbuflen) + (*(rxb+(rdp+3)%rxbuflen))*256;
 ycOrd++;
 if (ycOrd<64) SetValue(YCDB, lpChP->StaNo, ycOrd, ycValue);
 else SetValue(YCDB, lpChP->StaNo+1, ycOrd-64, ycValue);
 return 6;
}

BYTE Pyx(WORD rdp)
{
 BYTE FAR *rxb = lpChP->RecBuff;
 int yxbOrd = *(rxb+rdp) - 0xF8;
 int i, j;
 BYTE flag = (lpStaP+lpChP->StaNo)->RotateFlag;
 BYTE yxbv, yxtb, yxv[8];
 for (i=0; i<4; i++)
     {
      yxbv = *(rxb+(rdp+i+1)%rxbuflen);
      if (flag) yxbv = ByteRotate(yxbv);
      for (j=0, yxtb=0x80; j<8; j++, yxtb>>=1)
          {
           yxv[j] = 0;
           if (yxbv&yxtb) yxv[j]=1;
          }
	  if (yxbOrd<2)  SetBatchValue(YXDB, lpChP->StaNo, yxbOrd*32+i*8, 8, (char huge *)yxv);
	  else  SetBatchValue(YXDB, lpChP->StaNo+1, (yxbOrd-2)*32+i*8, 8, (char huge *)yxv);
     }
 return 6;
}

BYTE Pkwh(WORD rdp)
{
 BYTE FAR *rxb = lpChP->RecBuff;
 int kwhOrd = *(rxb+rdp) - 0xA3;
 DWORD kwhValue = (DWORD)*(rxb+(rdp+4)%rxbuflen)+(DWORD)*(rxb+(rdp+3)%rxbuflen)*256l
                 + (DWORD)*(rxb+(rdp+2)%rxbuflen)*256l*256l;
 if (kwhOrd<16) SetValue(KWHDB, lpChP->StaNo, kwhOrd, kwhValue);
 else  SetValue(KWHDB, lpChP->StaNo+1, kwhOrd-16, kwhValue);
 return 6;
}

BYTE Pyk(WORD rdp)
{
 if ((lpChP->RxWriteP+rxbuflen - lpChP->RxReadP)%rxbuflen <18 ) return 0;

 COMMAND cmdrcd;

 BYTE FAR *rxb = lpChP->RecBuff;
 BYTE rp = (lpStaP->DownCmdRP-1) & 3;
 WORD rtuno = lpStaP->DownCmd[rp].Cmd[0]+lpStaP->DownCmd[rp].Cmd[1]*256;
 if ((lpStaP->DownCmd[rp].Cmd[0]==DCMDYK0) && (lpChP->StaNo == rtuno))
    {
     cmdrcd.CmdContent[0] = 0x44;  //遥控返校
     cmdrcd.CmdContent[1] = lpStaP->DownCmd[rp].Cmd[1];
     cmdrcd.CmdContent[2] = lpStaP->DownCmd[rp].Cmd[2];
     cmdrcd.CmdContent[3] = *(rxb+(rdp+3)%rxbuflen);
     cmdrcd.CmdContent[4] = *(rxb+(rdp+4)%rxbuflen);
     cmdrcd.CmdContent[5] = *(rxb+(rdp+1)%rxbuflen);
     cmdrcd.CmdContent[6] = 0xAA;  //遥控返校错:0x55  遥控返校正确:0xAA
     cmdrcd.SubCmdType = TCZYKCMD;
     cmdrcd.DataLen = 0;
     cmdrcd.DataPt = 0;
     WriteACommand(COMMANDDB, SENDCMDBUF, &cmdrcd, NULL);
     lpStaP->DownCmd[rp].Cmd[0]=0;
	}

 return 18;
}

BYTE Psj(WORD rdp)
{
 if ((lpChP->RxWriteP+rxbuflen - lpChP->RxReadP)%rxbuflen <18 ) return 0;

 COMMAND cmdrcd;

 BYTE FAR *rxb = lpChP->RecBuff;
 BYTE rp = (lpStaP->DownCmdRP-1) & 3;
 WORD rtuno = lpStaP->DownCmd[rp].Cmd[0]+lpStaP->DownCmd[rp].Cmd[1]*256;
 if ((lpStaP->DownCmd[rp].Cmd[0]==DCMDSJ0) && (lpChP->StaNo == rtuno))
    {
     cmdrcd.CmdContent[0] = 0x44;  //遥调返校
     cmdrcd.CmdContent[1] = lpStaP->DownCmd[rp].Cmd[1];
     cmdrcd.CmdContent[2] = lpStaP->DownCmd[rp].Cmd[2];
     cmdrcd.CmdContent[3] = *(rxb+(rdp+3)%rxbuflen);
     cmdrcd.CmdContent[4] = *(rxb+(rdp+4)%rxbuflen);
     cmdrcd.CmdContent[5] = *(rxb+(rdp+1)%rxbuflen);
     cmdrcd.CmdContent[6] = 0xAA;  //遥调返校错:0x55  遥调返校正确:0xAA
     cmdrcd.SubCmdType = TCZYTCMD;
     cmdrcd.DataLen = 0;
     cmdrcd.DataPt = 0;
     WriteACommand(COMMANDDB, SENDCMDBUF, &cmdrcd, NULL);
     lpStaP->DownCmd[rp].Cmd[0]=0;
    }

 return 18;
}

BYTE Psoe(WORD rdp)
{
 if ((lpChP->RxWriteP+rxbuflen - lpChP->RxReadP)%rxbuflen <12 ) return 0;

 char bchdata[6];
 struct dosdate_t d;
 struct dostime_t t;
 int temp=0;
 BYTE FAR *rxb = lpChP->RecBuff;
 BYTE yxord, ret;
 DWORD yxattr;
 if ((*(rxb+rdp%rxbuflen)>=0x80) && (*(rxb+rdp%rxbuflen)<0x90)
     && (*(rxb+(rdp+6)%rxbuflen)>=0x90) && (*(rxb+(rdp+6)%rxbuflen)<0xa0))
    {
     for (int i=0; i<6; i++) bchdata[i] = *(rxb+(rdp+i+6)%rxbuflen);
     if (CDT_BCH(bchdata)==bchdata[5])
        {
		 if (*(rxb+(rdp+9)%rxbuflen)==0xff)
			 yxord = *(rxb+(rdp+10)%rxbuflen);
		 else yxord = *(rxb+(rdp+10)%rxbuflen)/16*10+*(rxb+(rdp+10)%rxbuflen)%16;
		 if (yxord<64) temp=0;else {temp=1;yxord-=64;}  
		 yxattr = GetAttr(YXDB, lpChP->StaNo+temp, yxord);
		 if ((yxattr&YXCREATESOE) && (yxattr&RECRTUSOE) )
			{
             EVENT evercd;
			 BYTE yxtype = GetType(YXDB, lpChP->StaNo+temp, yxord);
			 if (yxtype&YXSWITCH) evercd.EventType = KGEVENT;
             else if (yxtype&YXLINKER) evercd.EventType = DZEVENT;
			 else if (yxtype&YXPROTECT) evercd.EventType = BHEVENT;
			 evercd.EventType =1;
			 evercd.Station = lpChP->StaNo+temp;
             evercd.Order = yxord;
			 evercd.Status = *(rxb+(rdp+1)%rxbuflen);
			 evercd.Hour=*(rxb+(rdp+2)%rxbuflen)/16*10+*(rxb+(rdp+2)%rxbuflen)%16;
			 evercd.Min=*(rxb+(rdp+3)%rxbuflen)/16*10+*(rxb+(rdp+3)%rxbuflen)%16;
			 evercd.Sec=*(rxb+(rdp+4)%rxbuflen)/16*10+*(rxb+(rdp+4)%rxbuflen)%16;
			 evercd.Ms=*(rxb+(rdp+7)%rxbuflen)%16*100+*(rxb+(rdp+8)%rxbuflen)/16*10+*(rxb+(rdp+8)%rxbuflen)%16;;
			 if (yxattr&YXXOR) evercd.Status ^= 0xff;
             evercd.EventAttr &= ~SGFLAG;
             if (GetTimerValue(RTUDB, evercd.Station))
                {
				 if (evercd.Status==0x33)
                    {
                     if ((yxtype==YXSWITCH) || (yxtype==YXLINKER))
						 evercd.EventType|=0x80;//evercd.EventAttr |= SGFLAG;
                    }
				   else if (yxtype==YXPROTECT) evercd.EventType|=0x80;//evercd.EventAttr |= SGFLAG;
                }
			  _dos_getdate(&d);
              _dos_gettime(&t);
//              evercd.Year = d.year;
//              evercd.Mon = d.month;
//              evercd.Day = d.day;
/*
              evercd.Hour = t.hour;
              evercd.Min = t.minute;
              evercd.Sec = t.second;
			  evercd.Ms = 0;
*/
			  evercd.data[0]=evercd.Status;

			  if (
				   ((lpStaP+lpChP->StaNo)->Soe[0].ORDER!=yxord)||
				   ((lpStaP+lpChP->StaNo)->Soe[0].TIME!=evercd.Hour)||
				   ((lpStaP+lpChP->StaNo)->Soe[0].MINUTE!=evercd.Min)||
				   ((lpStaP+lpChP->StaNo)->Soe[0].SECOND!=evercd.Sec)||
				   ((lpStaP+lpChP->StaNo)->Soe[0].MSH!=evercd.Ms/100)||
				   ((lpStaP+lpChP->StaNo)->Soe[0].MSL!=evercd.Ms%100)||
				   ((lpStaP+lpChP->StaNo)->Soe[0].STATUS!=evercd.Status)
				  )


				{
				   (lpStaP+lpChP->StaNo)->Soe[0].ORDER=yxord;
				   (lpStaP+lpChP->StaNo)->Soe[0].TIME=evercd.Hour;
				   (lpStaP+lpChP->StaNo)->Soe[0].MINUTE=evercd.Min;
				   (lpStaP+lpChP->StaNo)->Soe[0].SECOND=evercd.Sec;
				   (lpStaP+lpChP->StaNo)->Soe[0].MSH=evercd.Ms/100;
				   (lpStaP+lpChP->StaNo)->Soe[0].MSL=evercd.Ms%100;
				   (lpStaP+lpChP->StaNo)->Soe[0].STATUS=evercd.Status;
		
					 WriteAEvent(EVENTDB, &evercd);
				}
            }
         ret=12;
        }
       else ret=6;
    }
   else ret=6;
 return ret;
}


//-----------------------------------------------------------------------------
WORD iTime(WORD wrp)
{
 struct time Time;
 BYTE bchdata[6]={0x70, 0xd9, 1, 1, 0, 0};
 BYTE FAR *txb = lpChP->SendBuff;

 bchdata[4] = lpStaP->DownCmd[lpStaP->DownCmdRP].Cmd[1];
 bchdata[5] = CDT_BCH(bchdata);
 for (int i=0; i<6; i++) *(txb+(wrp+i)%txbuflen) = bchdata[i];
 wrp = (wrp+6)%txbuflen;
 gettime (&Time);
 bchdata[0]=(Time.ti_hour/10*16)+Time.ti_hour%10;
 bchdata[1]=(Time.ti_min/10*16)+Time.ti_min%10;
 bchdata[2]=(Time.ti_sec/10*16)+Time.ti_sec%10;
 bchdata[3]=((Time.ti_hund*10)/256/10*16)+(Time.ti_hund*10)/256%10;
 bchdata[4]=((Time.ti_hund*10)%256/10*16+Time.ti_hund*10)%256%10;
 bchdata[5] = CDT_BCH(bchdata);
 for (i=0; i<6; i++) *(txb+(wrp+i)%txbuflen) = bchdata[i];
 wrp = (wrp+6)%txbuflen;

 return wrp;
}

WORD msYk(WORD wrp)
{
 BYTE bchdata[6]={0x70, 0x61, 3, 1, 0, 0};
 BYTE FAR *txb = lpChP->SendBuff;

 BYTE yktype = lpStaP->DownCmd[lpStaP->DownCmdRP].Cmd[0];
 if (yktype==DCMDYK0) bchdata[1] = 0x61;
   else if (yktype==DCMDYK1) bchdata[1] = 0xc2;
   else bchdata[1] = 0xb3;
 bchdata[4] = lpStaP->DownCmd[lpStaP->DownCmdRP].Cmd[1];
 bchdata[5] = CDT_BCH(bchdata);
 for (int i=0; i<6; i++) *(txb+(wrp+i)%txbuflen) = bchdata[i];
 wrp = (wrp+6)%txbuflen;

 bchdata[0]=0xe0;
 bchdata[1]=lpStaP->DownCmd[lpStaP->DownCmdRP].Cmd[5];
 bchdata[2]=0;
 bchdata[3]=lpStaP->DownCmd[lpStaP->DownCmdRP].Cmd[3];
 bchdata[4]=lpStaP->DownCmd[lpStaP->DownCmdRP].Cmd[4];
 bchdata[5] = CDT_BCH(bchdata);
 for (i=0; i<6; i++) *(txb+(wrp+i)%txbuflen) = bchdata[i];
 wrp = (wrp+6)%txbuflen;

 bchdata[0]=0xe1;
 bchdata[5] = CDT_BCH(bchdata);
 for (i=0; i<6; i++) *(txb+(wrp+i)%txbuflen) = bchdata[i];
 wrp = (wrp+6)%txbuflen;

 bchdata[0]=0xe2;
 bchdata[5] = CDT_BCH(bchdata);
 for (i=0; i<6; i++) *(txb+(wrp+i)%txbuflen) = bchdata[i];
 wrp = (wrp+6)%txbuflen;
/*
 EVENT evercd;
 struct date Date;
 struct time Time;

 evercd.EventType = YKEVENT;
 evercd.EventAttr = 0;
 if (yktype==DCMDYK0) evercd.EventAttr |= YKSET;
   else if (yktype==DCMDYK1) evercd.EventAttr |= YKEXEC;
   else evercd.EventAttr |= YKERASE;
 evercd.Station = (WORD)lpStaP->DownCmd[lpStaP->DownCmdRP].Cmd[1];
 evercd.Order = (WORD)lpStaP->DownCmd[lpStaP->DownCmdRP].Cmd[3];
 evercd.Status = (WORD)lpStaP->DownCmd[lpStaP->DownCmdRP].Cmd[5];
 getdate (&Date);
 evercd.Year = Date.da_year;
 evercd.Mon = Date.da_mon;
 evercd.Day = Date.da_day;
 gettime (&Time);
 evercd.Hour = Time.ti_hour;
 evercd.Min = Time.ti_min;
 evercd.Sec = Time.ti_sec;
 evercd.Ms = Time.ti_hund*10;
 WriteAEvent(EVENTDB, &evercd);
*/
 return wrp;
}

WORD msSj(WORD wrp)
{
 BYTE bchdata[6]={0x70, 0x61, 3, 1, 0, 0};
 BYTE FAR *txb = lpChP->SendBuff;

 BYTE yktype = lpStaP->DownCmd[lpStaP->DownCmdRP].Cmd[0];
 if (yktype==DCMDSJ0) bchdata[1] = 0x61;
   else if (yktype==DCMDSJ1) bchdata[1] = 0xc2;
   else bchdata[1] = 0xb3;
 bchdata[4] = lpStaP->DownCmd[lpStaP->DownCmdRP].Cmd[1];
 bchdata[5] = CDT_BCH(bchdata);
 for (int i=0; i<6; i++) *(txb+(wrp+i)%txbuflen) = bchdata[i];
 wrp = (wrp+6)%txbuflen;

 bchdata[0]=0xe9;
 if (lpStaP->DownCmd[lpStaP->DownCmdRP].Cmd[5]==0xcc) bchdata[1]=0xaa;
   else if (lpStaP->DownCmd[lpStaP->DownCmdRP].Cmd[5]==0x33) bchdata[1]=0x55;
   else bchdata[1]=0xff;
 bchdata[2]=0;
 bchdata[3]=lpStaP->DownCmd[lpStaP->DownCmdRP].Cmd[3];
 bchdata[4]=lpStaP->DownCmd[lpStaP->DownCmdRP].Cmd[4];
 bchdata[5] = CDT_BCH(bchdata);
 for (i=0; i<6; i++) *(txb+(wrp+i)%txbuflen) = bchdata[i];
 wrp = (wrp+6)%txbuflen;

 bchdata[0]=0xea;
 bchdata[5] = CDT_BCH(bchdata);
 for (i=0; i<6; i++) *(txb+(wrp+i)%txbuflen) = bchdata[i];
 wrp = (wrp+6)%txbuflen;

 bchdata[0]=0xeb;
 bchdata[5] = CDT_BCH(bchdata);
 for (i=0; i<6; i++) *(txb+(wrp+i)%txbuflen) = bchdata[i];
 wrp = (wrp+6)%txbuflen;

 return wrp;
}

WORD msGb(WORD wrp)
{
 BYTE bchdata[6]={0x70, 0xb, 0, 1, 0, 0};
 BYTE FAR *txb = lpChP->SendBuff;

 bchdata[4] = lpStaP->DownCmd[lpStaP->DownCmdRP].Cmd[1];
 bchdata[5] = CDT_BCH(bchdata);
 for (int i=0; i<6; i++) *(txb+(wrp+i)%txbuflen) = bchdata[i];
 wrp = (wrp+6)%txbuflen;

 return wrp;
}