realdb.cpp

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

int  TYcDB::GetYcValue(WORD stano, WORD ycno)
{
 TRtuDB rtu;
 if ( ycno >= rtu.GetStaYcNum(stano)) return 0;
 int iv = (WORD)dbGetIntField(rtu.GetStaYcStart(stano)+ycno, "实时值");
 return iv;
}

BYTE TYcDB::GetYcPoint(WORD stano, WORD ycno)
{
 TRtuDB rtu;
 if ( ycno >= rtu.GetStaYcNum(stano)) return 0;
 BYTE cv = (BYTE)dbGetNumField(rtu.GetStaYcStart(stano)+ycno, "小数位");
 return cv;
}
void  TYcDB::GetYcLineCoe(WORD stano, WORD ycno, YCLINECOE *yclinear)
{
 TRtuDB rtu;
 if ( ycno >= rtu.GetStaYcNum(stano))
    {
     yclinear->x1 = yclinear->x2 = yclinear->y1 = yclinear->y2 = 0;
    }
   else
    {
/*
     yclinear->x1 =(WORD) dbGetIntField(rtu.GetStaYcStart(stano)+ycno, "因子x1");
     yclinear->x2 =(WORD) dbGetIntField(rtu.GetStaYcStart(stano)+ycno, "因子x2");
     yclinear->y1 =(WORD) dbGetIntField(rtu.GetStaYcStart(stano)+ycno, "因子y1");
     yclinear->y2 =(WORD) dbGetIntField(rtu.GetStaYcStart(stano)+ycno, "因子y2");
*/
//TZC
/*
     yclinear->x1 =(WORD) dbGetIntField(rtu.GetStaYcStart(stano)+ycno, "因子X1");
     yclinear->x2 =(WORD) dbGetIntField(rtu.GetStaYcStart(stano)+ycno, "因子X2");
     yclinear->y1 =(WORD) dbGetIntField(rtu.GetStaYcStart(stano)+ycno, "因子Y1");
	 yclinear->y2 =(WORD) dbGetIntField(rtu.GetStaYcStart(stano)+ycno, "因子Y2");
*/
	 yclinear->x1 =(DWORD) dbGetLongField(rtu.GetStaYcStart(stano)+ycno, "因子X1");
	 yclinear->x2 =(DWORD) dbGetLongField(rtu.GetStaYcStart(stano)+ycno, "因子X2");
	 yclinear->y1 =(DWORD) dbGetLongField(rtu.GetStaYcStart(stano)+ycno, "因子Y1");
	 yclinear->y2 =(DWORD) dbGetLongField(rtu.GetStaYcStart(stano)+ycno, "因子Y2");

    }
}

void TYcDB::SetYcValue(WORD stano, WORD ycno, WORD ycvalue)
{
  TRtuDB rtu;
  DWORD  ycattr;
  int    ycr = ycvalue;
  if ( ycno >= rtu.GetStaYcNum(stano)) return;
  ycattr = GetYcAttr(stano, ycno);
  if (ycattr & YCREFRESH)  //允许刷新
	 {
/*
	  if (ycattr & YCNEG && !(ycattr & YCLINEAR))
		{
			if (ycr>=0)ycr = ycvalue ^ 0x8000;
			else ycr=(ycvalue&0x7fff)*(-1);
		}
*/

	  if (ycattr & YCLINEAR)
         {
          YCLINECOE ycl;
          GetYcLineCoe(stano, ycno, &ycl);
          if (ycl.x2 != ycl.x1)
			{
			  if (ycr>=0)
				  ycr = ((float)(ycl.y2-ycl.y1)/(float)(ycl.x2-ycl.x1))*(float)(ycvalue-ycl.x1);
			  else if (ycr<0)
              	{
	              ycvalue &=0x7fff;
				  ycr = ((float)(ycl.y2-ycl.y1)/(float)(ycl.x2-ycl.x1))*(float)(ycvalue-ycl.x1);
                  ycr |=0x8000;

				}

			}
		 }
	  if (ycattr & YCNEG)// && !(ycattr & YCLINEAR))
		{
        	ycr ^=0x8000;
		}

      dbSetIntField(rtu.GetStaYcStart(stano)+ycno, "实时值", ycr);
     }
}

void  TYcDB::SetYcAttr(WORD stano, WORD ycno, DWORD attr)
{
  TRtuDB rtu;
  if ( ycno >= rtu.GetStaYcNum(stano)) return;
  dbSetLongField(rtu.GetStaYcStart(stano)+ycno, "属性", attr);
}

void  TYcDB::SetYcPoint(WORD stano, WORD ycno, BYTE ycp)
{
  TRtuDB rtu;
  if ( ycno >= rtu.GetStaYcNum(stano)) return;
  DWORD ycattr = GetYcAttr(stano, ycno);
  if (ycattr & YCREFRESH)  //YC允许刷新
      dbSetNumField(rtu.GetStaYcStart(stano)+ycno, "小数位", (float)ycp);
}
//--------------------------------------------------------------------------------//
TKwhDB::TKwhDB() : TRealDB((int)KWHDB)
{
}
 
TKwhDB::~TKwhDB()
{
}

void TKwhDB::GetKwhName(WORD stano, WORD kwhno, char *kwhname)
{
 TRtuDB rtu;
 if ( kwhno >= rtu.GetStaKwhNum(stano)) *kwhname=0;
 dbGetStrField(rtu.GetStaKwhStart(stano)+kwhno, "电度名", kwhname);
}

DWORD  TKwhDB::GetKwhAttr(WORD stano, WORD kwhno)
{
 TRtuDB rtu;
 if ( kwhno >= rtu.GetStaKwhNum(stano)) return 0l;
 DWORD attr = (DWORD)dbGetLongField(rtu.GetStaKwhStart(stano)+kwhno, "属性");
 return attr;
}

DWORD  TKwhDB::GetKwhValue(WORD stano, WORD kwhno)
{
 TRtuDB rtu;
 if ( kwhno >= rtu.GetStaKwhNum(stano)) return 0l;
 DWORD dwv = (DWORD)dbGetLongField(rtu.GetStaKwhStart(stano)+kwhno, "实时值");
 return dwv;
}

BYTE  TKwhDB::GetKwhPoint(WORD stano, WORD kwhno)
{
 TRtuDB rtu;
 if ( kwhno >= rtu.GetStaKwhNum(stano)) return 0;
 BYTE cv = (BYTE)dbGetNumField(rtu.GetStaKwhStart(stano)+kwhno, "小数位");
 return cv;
}

void  TKwhDB::SetKwhValue(WORD stano, WORD kwhno, DWORD kwhvalue)
{
  TRtuDB rtu;
  DWORD  kwhattr;
  if ( kwhno >= rtu.GetStaKwhNum(stano)) return;
  kwhattr = GetKwhAttr(stano, kwhno);
  if (kwhattr & KWHREFRESH)  //允许刷新
     {
      dbSetLongField(rtu.GetStaKwhStart(stano)+kwhno, "实时值", kwhvalue);
     }
}

void  TKwhDB::SetKwhAttr(WORD stano, WORD kwhno, DWORD attr)
{
  TRtuDB rtu;
  if ( kwhno >= rtu.GetStaKwhNum(stano)) return;
  dbSetLongField(rtu.GetStaKwhStart(stano)+kwhno, "属性", attr);
}

void TKwhDB::SetKwhPoint(WORD stano, WORD kwhno, BYTE kwhp)
{
  TRtuDB rtu;
  if ( kwhno >= rtu.GetStaKwhNum(stano)) return;
  DWORD kwhattr = GetKwhAttr(stano, kwhno);
  if (kwhattr & KWHREFRESH)  //YC允许刷新
      dbSetNumField(rtu.GetStaKwhStart(stano)+kwhno, "小数位", (float)kwhp);
}

//--------------------------------------------------------------------------------//
TEventDB::TEventDB()
{
  lpEvent = (EVENT huge *)GlobalLock(hEventMem);
}

TEventDB::~TEventDB()
{
  GlobalUnlock(hEventMem);
}

void TEventDB::InitRWPointer()
{
  EventWP = 0;
  for (int i=0; i<EVEHANDLEMAXNUM; i++) EventRP[i]=EventWP;
}

WORD TEventDB::GetReadHandle()
{
 WORD hdl = 0xffff;
 for (int i=0; i<EVEHANDLEMAXNUM; i++)
    {
     if (!UsedFlag[i])
        {
         hdl = i;
         UsedFlag[i] = TRUE;
         EventRP[hdl] = EventWP;
         break;
        }
    }
 return hdl;
}

void  TEventDB::FreeReadHandle(WORD hdl)
{
  if (hdl<EVEHANDLEMAXNUM) UsedFlag[hdl]=FALSE;
}

void  TEventDB::WriteAEvent(EVENT *event)
{
 *(lpEvent+EventWP) = *event;
 EventWP++;
}

BOOL  TEventDB::ReadAEvent(WORD handle, EVENT *event)
{
 if (EventRP[handle] != EventWP)
    {
     *event = *(lpEvent+EventRP[handle]);
     EventRP[handle]++;
     return TRUE;
    }
   else return FALSE;
}

void huge * TEventDB::GetEventBuf()
{
  return lpEvent;
}

BYTE  TEventDB::GetEventWP()
{
  return EventWP;
}

//--------------------------------------------------------------------------------//
TCommandDB::TCommandDB()
{
  lpRecCmd = (COMMAND huge *)GlobalLock(hRecCmdMem);
  lpRecData = (BYTE huge *)GlobalLock(hRecDataMem);
  lpSendCmd = (COMMAND huge *)GlobalLock(hSendCmdMem);
  lpSendData = (BYTE huge *)GlobalLock(hSendDataMem);

}

TCommandDB::~TCommandDB()
{
  GlobalUnlock(hRecCmdMem);
  GlobalUnlock(hRecDataMem);
  GlobalUnlock(hSendCmdMem);
  GlobalUnlock(hSendDataMem);
}

void TCommandDB::InitRWPointer()
{
  RecCmdWP = 0;
  RecDataWP = 0;
  SendCmdWP = 0;
  SendDataWP = 0;
  for (int i=0; i<EVEHANDLEMAXNUM; i++)
      {
       RecCmdRP[i] = RecCmdWP;
       SendCmdRP[i] = SendCmdWP;
      }
}

WORD TCommandDB::GetReadHandle()
{
 WORD hdl;
 for (int i=0; i<CMDHANDLEMAXNUM; i++)
    {
     if (!UsedFlag[i])
        {
         hdl = i;
         UsedFlag[i] = TRUE;
         RecCmdRP[hdl] = RecCmdWP;
         SendCmdRP[hdl] = SendCmdWP;
         break;
        }
       else hdl = 0xffff;
    }
 return hdl;
}

void  TCommandDB::FreeReadHandle(WORD hdl)
{
  if (hdl<CMDHANDLEMAXNUM) UsedFlag[hdl]=FALSE;
}

void TCommandDB::WriteACmdToSend(COMMAND *cmd, char *cmddatap)
{
 if (!cmd) return;
 if ((cmd->DataLen) && (cmddatap!=NULL))
	{
     cmd->DataPt = SendDataWP;
     for (int i=0; i<cmd->DataLen; i++)
         {
          *(lpSendData+SendDataWP) = *(cmddatap+i);
          SendDataWP = (++SendDataWP)%CMDDATAMAX;   //SENDDATAMAX=4096
         }
    }
   else cmd->DataLen = 0;
 *(lpSendCmd+SendCmdWP%CMDMAXNUM) = *cmd;
 SendCmdWP = (++SendCmdWP)%CMDMAXNUM;
}

BOOL  TCommandDB::ReadACmdFromRec(WORD handle, COMMAND *cmd, char *cmddatap)
{
 if (RecCmdRP[handle] != RecCmdWP)
    {
     *cmd = *(lpRecCmd+RecCmdRP[handle]);
     if (cmd->DataLen && (cmddatap!=NULL))
        {
         RecDataRP = cmd->DataPt;
         for (int i=0; i<cmd->DataLen; i++)
             {
              *(cmddatap+i) = *(lpRecData+RecDataRP);
              RecDataRP = (++RecDataRP)%CMDDATAMAX;  //RECDATAMAX=4096
             }
        }
     RecCmdRP[handle] = (++RecCmdRP[handle])%CMDMAXNUM;
     return TRUE;
    }
   else return FALSE;
}

void  TCommandDB::WriteACmdToRec(COMMAND *cmd, char *cmddatap)
{
 if ((cmd->DataLen) && (cmddatap!=NULL))
    {
     cmd->DataPt = RecDataWP;
     for (int i=0; i<cmd->DataLen; i++)
         {
          *(lpRecData+RecDataWP) = *(cmddatap+i);
          RecDataWP = (++RecDataWP)%CMDDATAMAX;   //SENDDATAMAX=4096
         }
    }
   else cmd->DataLen = 0;
 *(lpRecCmd+RecCmdWP%CMDMAXNUM) = *cmd;
 RecCmdWP = (++RecCmdWP)%CMDMAXNUM;
}

BOOL  TCommandDB::ReadACmdFromSend(WORD handle, COMMAND *cmd, char *cmddatap)
{
 if (SendCmdRP[handle] != SendCmdWP)
	{
     *cmd = *(lpSendCmd+SendCmdRP[handle]);
     if (cmd->DataLen && (cmddatap!=NULL))
        {
         SendDataRP = cmd->DataPt;
         for (int i=0; i<cmd->DataLen; i++)
             {
              *(cmddatap+i) = *(lpSendData+SendDataRP);
              SendDataRP = (++SendDataRP)%CMDDATAMAX;  //RECDATAMAX=4096
             }
        }
     SendCmdRP[handle] = (++SendCmdRP[handle])%CMDMAXNUM;
     return TRUE;
    }
   else return FALSE;
}

void huge * TCommandDB::GetRecCmdBuf()
{
  return lpRecCmd;
}

void huge * TCommandDB::GetRecDataBuf()
{
  return lpRecData;
}

BYTE TCommandDB::GetRecCmdWP()
{
  return RecCmdWP;
}

void huge * TCommandDB::GetSendCmdBuf()
{
  return lpSendCmd;
}

void huge * TCommandDB::GetSendDataBuf()
{
  return lpSendData;
}

BYTE  TCommandDB::GetSendCmdWP()
{
  return SendCmdWP;
}