wdp.cpp

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

//wdp
#include <owl.h>
#include <windows.h>
#include <time.h>

#include "def.h"

#include "db.h"
#include "dbfile.h"
#include "cmdefs.h"

typedef struct {
  RUNFLAG rf;
  WORD    RecWPBak;
} CHFLAG;

char StationTemp[80];
BYTE Task[80];
/*
WORD  WdpEventHandel[80]={0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,
                          0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,
                          0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,
                          0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100,0x100
                          };
*/
WORD hRdSysEvent;
static HINSTANCE hinstLib=NULL;
static HINSTANCE hLib;
//---------------------------------------------------------------------------------
CHANNELPARAM FAR *lpChP=NULL;
STATIONPARAM FAR *lpStaP=NULL;
WORD rxbuflen = 256;
WORD txbuflen = 256;
WORD ChNo;
int FAR PASCAL _export RxProc(HWND, WORD, CHANNELPARAM FAR *, STATIONPARAM FAR *);
int FAR PASCAL _export TxProc(HWND, CHANNELPARAM FAR *, STATIONPARAM FAR *,int);

extern BYTE FAR PASCAL _export CDT_BCH(BYTE *);
extern BYTE FAR PASCAL _export ByteRotate(BYTE srcbyte);
//typedef BYTE (*PROC1)(BYTE *);
//PROC1 CDT_BCH;

void ProcCtrlW(WORD);
BYTE ProcInfoW(WORD);
BYTE Pyc(WORD);
BYTE Pyx(WORD);
BYTE Pkwh(WORD);
BYTE Pyk(WORD);
BYTE Psj(WORD);
BYTE Psoe(WORD);

WORD iTime(WORD);
WORD msYk(WORD);
WORD msSj(WORD);
WORD msGb(WORD);
WORD TxWdp(WORD,WORD);
WORD WdpSendYx(WORD,WORD);
WORD WdpSendYc(WORD,WORD);
WORD WdpSendKwh(WORD,WORD);
WORD WdpSendSoe(WORD,WORD);
WORD CalBCD(WORD);
BYTE CallLPC(BYTE FAR *,WORD,WORD,WORD);
//========================================================================================
int FAR PASCAL LibMain(HANDLE hInstance, WORD wDataSeg, WORD wHeapSize, LPSTR lpszCmdLine)
{
  if (wHeapSize >0 ) UnlockData(0);
/*  if (!hinstLib)
	 {
      hLib = LoadLibrary ("PUBPROC.DLL");
      if (hLib < (HINSTANCE)32)  return 0;
      CDT_BCH = (PROC1)GetProcAddress(hLib, "CDT_BCH");
      hinstLib = hInstance;
	 }  */
  return 1;
}
int FAR PASCAL WEP (int nParameter)
{
  FreeLibrary (hLib);
  return 1;
} 
//=============================================================================================================
int FAR PASCAL _export RxProc(HWND hWnd, WORD chno, CHANNELPARAM FAR *lpChannelP, STATIONPARAM FAR *lpStationP)
{
  WORD rdp;
  char FAR *rxb;
  BYTE bchdata[6];

  lpStaP = lpStationP;
  if (!lpStaP) return 0;
  lpChP = lpChannelP;
  if (!lpChP) return 0;
  ChNo = chno;
  lpChP += ChNo;
  rxb = lpChP->RecBuff;
  if (!rxb) return 0;
  rxbuflen = lpChP->RxBuffLen;
  CHFLAG *chf = (CHFLAG *)lpChP->Reserved;

  if ((chf->RecWPBak%rxbuflen)==(lpChP->RxWriteP%rxbuflen))  //如果接收写指针没变化
     {
      if (!(lpChP->CHStatus & CommBreakFlag))
         {
          if (++chf->rf.CommBreakNum > 400)
             {
//              lpChP->CHStatus |= CommBreakFlag;
//			  lpChP->CHStatus |= ChInit;
//              lpChP->CHStatus &= ~(SyncR + CtrlW +InforW);
             }
         }
	 }
    else
	 {
      chf->RecWPBak = lpChP->RxWriteP%rxbuflen;


//      chf->rf.CommBreakNum = 0;
      if (lpChP->CHStatus & CommBreakFlag)
         {
          if (chf->rf.CommBreakNum==0)
              lpChP->CHStatus &= ~CommBreakFlag;
            else
             chf->rf.CommBreakNum--;
         }
        else
		 chf->rf.CommBreakNum = 0;

    }

  if (chf->rf.InvalidCharNum>0x1e0)
     {
      lpChP->CHStatus |= ChInit;
      chf->rf.InvalidCharNum = 0;
      if ((++chf->rf.CHErr)>0x580)
         {
          chf->rf.CHErr = 0;
          lpChP->CHStatus |= CharInvFlag;
          lpChP->CHStatus &= ~(SyncR + CtrlW +InforW);
         }
     }


  while (((lpChP->RxWriteP+rxbuflen - lpChP->RxReadP)%rxbuflen)>=24)
		{

  	if ((lpStaP+lpChP->StaNo)->CurrUsedCh!=ChNo)
  	  { lpChP->RxReadP=(lpChP->RxReadP+1)%rxbuflen;return 1;}


		 rdp = lpChP->RxReadP;
		 if (!(lpChP->CHStatus & SyncR))   //如果没有同步字
            {
			 if ((*(rxb+rdp)==lpChP->SyncWord[0]) && (*(rxb+(rdp+1)%rxbuflen)==lpChP->SyncWord[1]) &&
				 (*(rxb+(rdp+2)%rxbuflen)==lpChP->SyncWord[0]) && (*(rxb+(rdp+3)%rxbuflen)==lpChP->SyncWord[1]) &&
                 (*(rxb+(rdp+4)%rxbuflen)==lpChP->SyncWord[0]) && (*(rxb+(rdp+5)%rxbuflen)==lpChP->SyncWord[1]))
                {
chf->rf.CommBreakNum=0;
lpChP->CHStatus &=~CommBreakFlag;

				 lpChP->CHStatus |= SyncR;
                 chf->rf.NoSyncNum = 0;
                 chf->rf.OnlySyncNum = 0;
                 lpChP->CHStatus &= ~(CtrlW+InforW+CharInvFlag+NoSyncFlag);
                 lpChP->RxReadP = (rdp+6)%rxbuflen;
                 break;
                }
               else
				{
                 lpChP->RxReadP = (rdp+1)%rxbuflen;
		  		 chf->rf.NoSyncNum++;
				 if (chf->rf.NoSyncNum>800)
                    {
					 lpChP->CHStatus |= ChInit;
					 lpChP->CHStatus |= NoSyncFlag;
					 chf->rf.NoSyncNum =0;
                     if ((++chf->rf.CHErr)>0x180)
                        {
                         chf->rf.CHErr = 0;
                         lpChP->CHStatus |= NoSyncFlag;
						}
                    }
                 continue;
                }
            }
           else // 
            {
             if ((*(rxb+rdp)==lpChP->SyncWord[0]) && (*(rxb+(rdp+1)%rxbuflen)==lpChP->SyncWord[1]) &&
                 (*(rxb+(rdp+2)%rxbuflen)==lpChP->SyncWord[0]) && (*(rxb+(rdp+3)%rxbuflen)==lpChP->SyncWord[1]) &&
                 (*(rxb+(rdp+4)%rxbuflen)==lpChP->SyncWord[0]) && (*(rxb+(rdp+5)%rxbuflen)==lpChP->SyncWord[1]))
                {
                 // 有同步字 又收到同步字
                  lpChP->RxReadP = (rdp+6)%rxbuflen;
                  lpChP->CHStatus &= ~(CtrlW+InforW);
                  chf->rf.OnlySyncNum++;
                  if (chf->rf.OnlySyncNum>600)
                     {
                      lpChP->CHStatus |= ChInit;
                      chf->rf.OnlySyncNum = 0;
                      if ((++chf->rf.CHErr)>0x180)
                         {
						  chf->rf.CHErr = 0;
                          lpChP->CHStatus |= OnlySyncFlag;
                         }
                      }
                  break;
                }
               else if(!(lpChP->CHStatus & CtrlW))  //有同步字 没有控制字
                {
            	 lpChP->CHStatus |= CtrlW;
	             lpChP->CHStatus &= ~InforW;
                 for (int i=0; i<6; i++) bchdata[i] = *(rxb+(rdp+i)%rxbuflen);
                 if (CDT_BCH(bchdata)==bchdata[5])
					{
                     //如果本通道是当前站正在使用的通道，则处理控制字
                     if ((lpStaP+lpChP->StaNo)->CurrUsedCh==ChNo)  
						 ProcCtrlW(rdp);
						 rdp+=5;
					}
	  			 else  lpChP->ErrDataNum++;
				 lpChP->RxReadP = (rdp+1)%rxbuflen;
                 break;
                }
               else //有同步字 有控制字
                {
                 for (int i=0; i<6; i++) bchdata[i] = *(rxb+(rdp+i)%rxbuflen);
                 if (CDT_BCH(bchdata)==bchdata[5])
                    {
                     //如果本通道是当前站正在使用的通道，则处理信息字
//                    if ((lpStaP+lpChP->StaNo)->CurrUsedCh==ChNo)  
//                         lpChP->RxReadP = (rdp + ProcInfoW(rdp))%rxbuflen;
//					   else
						 lpChP->RxReadP = (rdp+6)%rxbuflen;
					 break;
                    }
				   else if((lpStaP+lpChP->StaNo)->CurrUsedCh==ChNo)
					{ 
					 lpChP->ErrDataNum++;
					 for (int temp=1;temp<17;temp++)
						{
							for (i=0; i<6; i++) bchdata[i] = *(rxb+(rdp+i+temp)%rxbuflen);
							if  (CDT_BCH(bchdata)==bchdata[5]) break;
						}
					 lpChP->RxReadP = (rdp+temp)%rxbuflen;
					 if (temp>=17)     lpChP->CHStatus &= ~ (SyncR+CtrlW);
					 
					// if (temp<6) lpChP->ErrDataNum--;
					 break;
                    }
				} //end else if
            } //end else
        } // end while
  return 1;
}
int FAR PASCAL _export TxProc(HWND hWnd, CHANNELPARAM FAR *lpChannelP, STATIONPARAM FAR *lpStationP,int Station)
{
 WORD wrp,currch;
 char FAR *txb;
   lpChP = lpChannelP;
   if (!lpChP) return 0;
   lpStaP = lpStationP;
   txb = lpChP->SendBuff;
   if (!txb) return 0;
   txbuflen=lpChP->TxBuffLen;
   wrp = lpChP->TxWriteP%txbuflen;
   if (wrp != lpChP->TxReadP%txbuflen) return 0;
//   if (WdpEventHandel[Station]==0x100) WdpEventHandel[Station] = GetReadHandle(EVENTDB);

   wrp=TxWdp(wrp,Station);
/*
   if (lpStaP->DownCmdRP != lpStaP->DownCmdWP)
      {
	   *(txb+wrp) = *(txb+(wrp+2)%txbuflen) = *(txb+(wrp+4)%txbuflen) = lpChP->SyncWord[0];
       *(txb+(wrp+1)%txbuflen) = *(txb+(wrp+3)%txbuflen) = *(txb+(wrp+5)%txbuflen) = lpChP->SyncWord[1];
       wrp = (wrp+6)%txbuflen;

	   switch (lpStaP->DownCmd[lpStaP->DownCmdRP].Cmd[0])
         {
		  case DCMDSST: //对钟
			   wrp = iTime(wrp);
               break;
          case DCMDYK0: //遥控预置
          case DCMDYK1: //遥控执行
		  case DCMDYK2: //遥控撤消
			   wrp = msYk(wrp);
			   break;
          case DCMDSJ0: //升降选择
          case DCMDSJ1: //升降执行
          case DCMDSJ2: //升降撤消
               wrp = msSj(wrp);
               break;
          case DCMDGB:  //广播命令
               wrp = msGb(wrp); 
               break;
//          case DCMDFG:
//               break;
         }
       lpStaP->DownCmdRP = (lpStaP->DownCmdRP+1)&3;
	  }
*/
 lpChP->TxWriteP=(wrp)%txbuflen;
 return 1;
}

void ProcCtrlW(WORD rdp)
{
  if (!lpChP) return;
  BYTE FAR *rxb = lpChP->RecBuff;

//  lpChP->StaNo = *(rxb+(rdp+3)%rxbuflen);
	BYTE StaNo = *(rxb+(rdp+3)%rxbuflen);
  //如果本通道不是当前站正在使用的通道，则退出
//  if ((lpStaP+lpChP->StaNo)->CurrUsedCh!=ChNo) return; 

  switch (*(rxb+(rdp+1)%rxbuflen))
    {
     case 0x7a:    
          COMMAND cmdrcd;
		  BYTE rp = ((lpStaP+lpChP->StaNo)->DownCmdRP-1) & 3;
          WORD rtuno = (lpStaP+lpChP->StaNo)->DownCmd[rp].Cmd[0]+(lpStaP+lpChP->StaNo)->DownCmd[rp].Cmd[1]*256+1;
          if (((lpStaP+lpChP->StaNo)->DownCmd[rp].Cmd[0]==DCMDYK0) && (StaNo == rtuno))
			 {
              cmdrcd.CmdContent[0] = 0x44;  //遥控返校
              for (int i=1; i<6; i++)
                   cmdrcd.CmdContent[i] = lpStaP->DownCmd[rp].Cmd[i];
              cmdrcd.CmdContent[6] = 0x55;  //遥控返校错:0x55  遥控返校正确:0xAA
              cmdrcd.SubCmdType = TCZYKCMD;
              cmdrcd.DataLen = 0;
              cmdrcd.DataPt = 0;
              WriteACommand(COMMANDDB, SENDCMDBUF, &cmdrcd, NULL);
              (lpStaP+lpChP->StaNo)->DownCmd[rp].Cmd[0]=0;
             }   
          break;
     default:
          break;
    }
}

BYTE ProcInfoW(WORD rdp)
{
  BYTE FAR *rxb = lpChP->RecBuff;
  BYTE func = *(rxb+rdp);
  BYTE Add;
  
  WORD yxno = GetRcdNum(YXDB, lpChP->StaNo);
  WORD yxno1 = GetRcdNum(YXDB, lpChP->StaNo+1);


  if (func==0)     //时间
     { Add = 6;     }
    else if (func<0x80)  //遥测
     { Add = Pyc(rdp);      }
    else if (func<0xa0)  //SOE
     { Add = Psoe(rdp);     }
    else if (func<0xa1)  //频率
     { Add = 6;     }
    else if (func<0xa3)  //水位
     { Add = 6;     }
    else if (func<0xd0)  //电度
     { Add = Pkwh(rdp);     }
    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 bchdata[6];
BYTE FAR *rxb = lpChP->RecBuff;
for (int i=0; i<6; i++) bchdata[i] = *(rxb+(rdp+i)%rxbuflen);
   if (CDT_BCH(bchdata)!=bchdata[5]) return 6;

 int ycOrd = (*(rxb+rdp)-1)*2;
 int ycValue = *(rxb+(rdp+2)%rxbuflen) + (*(rxb+(rdp+1)%rxbuflen))*256;
 SetValue(YCDB, lpChP->StaNo, ycOrd, ycValue);
 ycValue = *(rxb+(rdp+4)%rxbuflen) + (*(rxb+(rdp+3)%rxbuflen))*256;
 ycOrd++;
 SetValue(YCDB, lpChP->StaNo, ycOrd, 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;
          }
	  SetBatchValue(YXDB, lpChP->StaNo, yxbOrd*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;
 SetValue(KWHDB, lpChP->StaNo, kwhOrd, 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+lpChP->StaNo)->DownCmdRP-1) & 3;
 WORD rtuno = (lpStaP+lpChP->StaNo)->DownCmd[rp].Cmd[0]+(lpStaP+lpChP->StaNo)->DownCmd[rp].Cmd[1]*256+1;
 if (((lpStaP+lpChP->StaNo)->DownCmd[rp].Cmd[0]==DCMDYK0))// && (lpChP->StaNo == rtuno))
    {
     cmdrcd.CmdContent[0] = 0x44;  //遥控返校
     cmdrcd.CmdContent[1] = (lpStaP+lpChP->StaNo)->DownCmd[rp].Cmd[1];
     cmdrcd.CmdContent[2] = (lpStaP+lpChP->StaNo)->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);