realdb.cpp

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

#include	<windows.h>
#include    <stdio.h>
#include    <stdarg.h>
#include    <dos.h>

#include  "def.h"
#include  "db.h"
#include  "dbfile.h"
#include  "cmdefs.h"
//-- 定义实时数据库全局变量
#define DBMAXNUM   9


char *DbFileName[]={"c:\\tcz\\xtcsk.dbf", "c:\\tcz\\yxcsk.dbf", "c:\\tcz\\yccsk.dbf",
                    "c:\\tcz\\ddcsk.dbf", "c:\\tcz\\zfcsk.dbf", "c:\\tcz\\zfyc.dbf",
                    "c:\\tcz\\zfyx.dbf", "c:\\tcz\\zfdd.dbf","c:\\tcz\\calc.dbf"
                   };
int DBNUM;
int ycnum[47];
int yxnum[47];
int kwhnum[47];
HGLOBAL  hRealDbMem[DBMAXNUM];
char huge *lpRealDb[DBMAXNUM];
HGLOBAL  hEventMem = NULL;
HGLOBAL  hRecCmdMem = NULL;
HGLOBAL  hRecDataMem = NULL;
HGLOBAL  hSendCmdMem = NULL;
HGLOBAL  hSendDataMem = NULL;
HGLOBAL  hRtuInxMem = NULL;
HGLOBAL  zfhRtuInxMem = NULL;
int      zfrtunum;
BYTE TEventDB::EventWP = 0;
BOOL TEventDB::UsedFlag[EVEHANDLEMAXNUM];
BYTE TEventDB::EventRP[EVEHANDLEMAXNUM];
BYTE TCommandDB::RecCmdWP = 0;
BYTE TCommandDB::RecDataWP = 0;
BYTE TCommandDB::SendCmdWP = 0;
BYTE TCommandDB::SendDataWP = 0;
BOOL TCommandDB::UsedFlag[CMDHANDLEMAXNUM];
BYTE TCommandDB::RecCmdRP[CMDHANDLEMAXNUM];
BYTE TCommandDB::SendCmdRP[CMDHANDLEMAXNUM];
BOOL LoadAllDBFile(void);
BOOL FreeAllDBFile(void);
//----------------------------------------------------------------//
BOOL LoadAllDBFile(void)
{
    OFSTRUCT     OfS;
    HFILE        hf; 
    DBFILEHEAD   Header;
    DWORD        len;
    int          i,j;

    for (i=0; i<DBMAXNUM; i++)
        {
         hRealDbMem[i] = NULL;
         lpRealDb[i] = NULL;
         hf = OpenFile((LPSTR)DbFileName[i], (LPOFSTRUCT)&OfS, OF_READ);
         if (hf != HFILE_ERROR)
            {
             _lread(hf, (LPSTR)&Header, sizeof(DBFILEHEAD));
             // shy 98.4
             len = (DWORD)Header.HeaderLen + (DWORD)Header.RecordLen*(DWORD)Header.RecordNum;
             hRealDbMem[i] = GlobalAlloc (GMEM_NODISCARD|GMEM_MOVEABLE|GMEM_SHARE|GMEM_ZEROINIT, len);
//             if (!hRealDbMem[i])MessageBox (NULL, "", "Alloc Error", MB_OK);
             if (!hRealDbMem[i]) return FALSE;
             lpRealDb[i] = (char huge *)GlobalLock(hRealDbMem[i]);

             _llseek(hf, 0, 0);
             _lread(hf, lpRealDb[i], Header.HeaderLen);
             for (j=0; j<Header.RecordNum; j++)
                  //shy 98.4
                  _lread(hf, lpRealDb[i]+(DWORD)Header.HeaderLen+(DWORD)Header.RecordLen*(DWORD)j, Header.RecordLen);
             _lclose(hf);
             GlobalUnlock(hRealDbMem[i]);
            }
        }

    // 根据 RTU 个数及定义，建立站索引
    TRtuDB rtu;
    int rtunum = rtu.dbGetRcdNum();
    if (rtunum)
       {
        hRtuInxMem = GlobalAlloc(GMEM_NODISCARD|GMEM_MOVEABLE|GMEM_SHARE|GMEM_ZEROINIT, (DWORD)sizeof(RTUINDEX)*(DWORD)rtunum);
		RTUINDEX huge *lpRtuInx = (RTUINDEX huge *)GlobalLock(hRtuInxMem);
        lpRtuInx->YxStart = 0;
        lpRtuInx->YcStart = 0;
        lpRtuInx->KwhStart = 0;
        lpRtuInx->EvidentNum = 0;
        for (i=1; i<rtunum+1; i++)
            {
             (lpRtuInx+i)->YxStart = (lpRtuInx+i-1)->YxStart+rtu.GetStaYxNum(i-1);
             (lpRtuInx+i)->YcStart = (lpRtuInx+i-1)->YcStart+rtu.GetStaYcNum(i-1);
             (lpRtuInx+i)->KwhStart = (lpRtuInx+i-1)->KwhStart+rtu.GetStaKwhNum(i-1);
             yxnum[i-1]= rtu.GetStaYxNum(i-1);
             ycnum[i-1]= rtu.GetStaYcNum(i-1);
             kwhnum[i-1]=rtu.GetStaKwhNum(i-1);
             (lpRtuInx+i)->EvidentNum = 0;
            }
        GlobalUnlock(hRtuInxMem);
       }
    ZFDB zf;
    zfrtunum = zf.dbGetRcdNum();
    if (zfrtunum!=0)
       {
        zfhRtuInxMem = GlobalAlloc(GMEM_NODISCARD|GMEM_MOVEABLE|GMEM_SHARE|GMEM_ZEROINIT, (DWORD)sizeof(RTUINDEX)*(DWORD)zfrtunum);
        RTUINDEX huge *zflpRtuInx = (RTUINDEX huge *)GlobalLock(zfhRtuInxMem);
        zflpRtuInx->YxStart = 0;
        zflpRtuInx->YcStart = 0;
        zflpRtuInx->KwhStart = 0;
        zflpRtuInx->EvidentNum = 0;

        for (i=1; i<zfrtunum; i++)
            {
             (zflpRtuInx+i)->YxStart = (zflpRtuInx+i-1)->YxStart+zf.GetStaYxNum(i-1);
             (zflpRtuInx+i)->YcStart = (zflpRtuInx+i-1)->YcStart+zf.GetStaYcNum(i-1);
             (zflpRtuInx+i)->KwhStart = (zflpRtuInx+i-1)->KwhStart+zf.GetStaKwhNum(i-1);
             (zflpRtuInx+i)->EvidentNum = 0;
			}

        GlobalUnlock(zfhRtuInxMem);
       }

    // 建立事项(EVENT)缓冲区和收发命令(COMMAND)缓冲区
    hEventMem = GlobalAlloc(GMEM_NODISCARD|GMEM_MOVEABLE|GMEM_SHARE|GMEM_ZEROINIT, (DWORD)sizeof(EVENT)*(DWORD)EVENTMAXNUM);
    hRecCmdMem = GlobalAlloc(GMEM_NODISCARD|GMEM_MOVEABLE|GMEM_SHARE|GMEM_ZEROINIT, (DWORD)sizeof(COMMAND)*(DWORD)CMDMAXNUM);
    hRecDataMem = GlobalAlloc(GMEM_NODISCARD|GMEM_MOVEABLE|GMEM_SHARE|GMEM_ZEROINIT, (DWORD)(DWORD)CMDDATAMAX);
    hSendCmdMem = GlobalAlloc(GMEM_NODISCARD|GMEM_MOVEABLE|GMEM_SHARE|GMEM_ZEROINIT, (DWORD)sizeof(COMMAND)*(DWORD)CMDMAXNUM);
    hSendDataMem = GlobalAlloc(GMEM_NODISCARD|GMEM_MOVEABLE|GMEM_NODISCARD|GMEM_MOVEABLE|GMEM_SHARE|GMEM_ZEROINIT, (DWORD)CMDDATAMAX);

    TEventDB eve;
    eve.InitRWPointer();
    TCommandDB cmd;
    cmd.InitRWPointer();

    return TRUE;
}
//----------------------------------------------------------------//
BOOL FreeAllDBFile(void)
{
  for (int i=0; i<DBMAXNUM; i++)
      {
       GlobalFree(hRealDbMem[i]);
	  }
  GlobalFree(hEventMem);
  return TRUE;
}

//----------------------------------------- tcz----------------------//
TRealDB::TRealDB(char *)
{
}

TRealDB::TRealDB(int DbNo)                         
{
  dbfhead = NULL;
  dbfield = NULL;
  dbrecord = NULL;
  FieldNum = 0;
  dbno = DbNo;

  lpDbf = (char huge *)GlobalLock(hRealDbMem[dbno]);
  if (lpDbf)
     {
      dbfhead = (DBFILEHEAD huge *)lpDbf;
      dbfield = (DBFIELD huge *)(lpDbf + sizeof(DBFILEHEAD));
	  dbrecord = lpDbf + dbfhead->HeaderLen;
      FieldNum = dbfhead->HeaderLen-sizeof(DBFILEHEAD)/sizeof(DBFIELD);
     }
}

TRealDB::~TRealDB()
{
  GlobalUnlock(hRealDbMem[dbno]);
}

BOOL TRealDB::dbGetAField(char *FieldName, DBFIELD *DBField)
{

 if (!lstrcmp(FieldName, "实时值") && dbno<=2)
    {
        *DBField = *(dbfield+2+dbno);
        return TRUE;
    }

 if (!lstrcmp(FieldName, "实时值") && dbno==3)
    {
        *DBField = *(dbfield+4);
        return TRUE;
    }

 if (dbfield)
    {
     for (int i=0; i<FieldNum; i++)
         {
          if (!lstrcmp(FieldName, (dbfield+i)->FieldName))
             {
              *DBField = *(dbfield+i);
              return TRUE;
             }
         }
    }
 return FALSE;
}

BOOL TRealDB::dbGetFileHead(DBFILEHEAD huge *dbfilehead)
{
 if (dbfhead)
    { dbfilehead = dbfhead;   return TRUE; } 
 return FALSE;
}

long  TRealDB::dbGetRcdNum()
{
 if (dbfhead) return (dbfhead->RecordNum);
   else return 0;
}

void  TRealDB::dbGetStrField(DWORD rcdno, int fieldID, char *str)
{
 
} 

void  TRealDB::dbGetStrField(DWORD rcdno, char *fieldname, char *str)
{
 DBFIELD dbf; 
//shy 98.4
 if (dbGetAField(fieldname, &dbf) && (rcdno<dbfhead->RecordNum))
    {
     for (DWORD i=0; i<dbf.FieldWidth; i++)
          str[i]=*(dbrecord+(DWORD)rcdno*(DWORD)dbfhead->RecordLen+(DWORD)dbf.FieldOffset+i);
     str[dbf.FieldWidth]=0;
    }
   else str[0]='\0'; 
}

char TRealDB::dbGetCharField(DWORD rcdno, int fieldID)
{
 return(0);
}

char TRealDB::dbGetCharField(DWORD rcdno, char *fieldname)
{
 DBFIELD dbf;

 if (dbGetAField(fieldname, &dbf) && (rcdno<dbfhead->RecordNum))
    {
     return *(char *)(dbrecord+rcdno*(dbfhead->RecordLen)+dbf.FieldOffset);
    }
   else return(0);
}

float TRealDB::dbGetNumField(DWORD rcdno, int fieldID)
{
 return(0.0);
}

float TRealDB::dbGetNumField(DWORD rcdno, char *fieldname)
{
 DBFIELD dbf;

 if (dbGetAField(fieldname, &dbf) && (rcdno<dbfhead->RecordNum))
    {
     float fv;
     char str[50];
     for (int i=0; i<dbf.FieldWidth; i++)
          str[i] = *(dbrecord+rcdno*(dbfhead->RecordLen)+dbf.FieldOffset+i);
     str[dbf.FieldWidth] = 0;
     sscanf(str, "%f", &fv);
     return fv;
    }
   else return(0.0);
}

int TRealDB::dbGetIntField(DWORD rcdno, int fieldID)
{
 return(0);
}

int TRealDB::dbGetIntField(DWORD rcdno, char *fieldname)
{
 DBFIELD dbf;
 if (dbGetAField(fieldname, &dbf) && (rcdno<dbfhead->RecordNum))
    {
     return *(int*)(dbrecord+rcdno*(dbfhead->RecordLen)+dbf.FieldOffset);
    }
   else return(0);
}

long TRealDB::dbGetLongField(DWORD rcdno, int fieldID)
{
 return(0);
}

long TRealDB::dbGetLongField(DWORD rcdno, char *fieldname)
{                                          
 DBFIELD dbf;

 if (dbGetAField(fieldname, &dbf) && (rcdno<dbfhead->RecordNum))
    {
     return *(long *)(dbrecord+rcdno*(dbfhead->RecordLen)+dbf.FieldOffset);
    }
   else return(0l);
}

void TRealDB::dbSetCharField(DWORD rcdno, int fieldID, char cvalue)
{
}

void TRealDB::dbSetCharField(DWORD rcdno, char *fieldname, char cvalue)
{
 DBFIELD dbf;

 if (dbGetAField(fieldname, &dbf) && (rcdno<dbfhead->RecordNum))
    {
     *(char *)(dbrecord+rcdno*(dbfhead->RecordLen)+dbf.FieldOffset)=cvalue;
    }
}

void TRealDB::dbSetNumField(DWORD rcdno, int fieldID, float nvalue)
{
}

void TRealDB::dbSetNumField(DWORD rcdno, char *fieldname, float nvalue)
{
 DBFIELD dbf;

 if (dbGetAField(fieldname, &dbf) && (rcdno<dbfhead->RecordNum) && (dbf.FieldType=='N'))
    {
     char str[50], str1[10];
     sprintf(str1, "%s%d.%df", "%0", dbf.FieldWidth, dbf.DecimalPoint);
     sprintf(str, str1, nvalue);
     for (int i=0; i<dbf.FieldWidth; i++)
          *(char *)(dbrecord+rcdno*(dbfhead->RecordLen)+dbf.FieldOffset+i)=str[i];
    }
}

void TRealDB::dbSetIntField(DWORD rcdno, int fieldID, int ivalue)
{
}

void TRealDB::dbSetIntField(DWORD rcdno, char *fieldname, int ivalue)
{
 DBFIELD dbf;

 if (dbGetAField(fieldname, &dbf) && (rcdno<dbfhead->RecordNum))
    {
     *(int *)(dbrecord+rcdno*(dbfhead->RecordLen)+dbf.FieldOffset)=ivalue;
    }
}

void TRealDB::dbSetLongField(DWORD rcdno, int fieldID, long lvalue)
{
}

void TRealDB::dbSetLongField(DWORD rcdno, char *fieldname, long lvalue)
{
 DBFIELD dbf;

 if (dbGetAField(fieldname, &dbf) && (rcdno<dbfhead->RecordNum))
    {           
     *(long *)(dbrecord+rcdno*(dbfhead->RecordLen)+dbf.FieldOffset)=lvalue;
    }
}   

CALC::CALC(): TRealDB((int)CALCULATE)
{          
}
CALC::~CALC()
{
}
int CALC::GetSStation(WORD Record,BYTE SymNo)
{
/*	char COUNT[5]={"站号1"};
    COUNT[4]=SymNo+0x2f;
	return dbGetIntField(Record,COUNT);
*/
	if (SymNo==0) 	return (BYTE)dbGetIntField(Record,"站号A");
	if (SymNo==1) 	return (BYTE)dbGetIntField(Record,"站号B");
	if (SymNo==2) 	return (BYTE)dbGetIntField(Record,"站号C");
	if (SymNo==3) 	return (BYTE)dbGetIntField(Record,"站号D");
	if (SymNo==4) 	return (BYTE)dbGetIntField(Record,"站号E");
	if (SymNo==5) 	return (BYTE)dbGetIntField(Record,"站号F");
	if (SymNo==6) 	return (BYTE)dbGetIntField(Record,"站号G");
	if (SymNo==7) 	return (BYTE)dbGetIntField(Record,"站号H");
	if (SymNo==8) 	return (BYTE)dbGetIntField(Record,"站号I");
	if (SymNo==9) 	return (BYTE)dbGetIntField(Record,"站号J");
    return 0;
}
int CALC::GetDStation(WORD Record,BYTE SymNo)
{
	return (int) dbGetIntField(Record,"目的");
}
BYTE CALC::GetSymbol(WORD Record,BYTE SymNo)
{
   if (SymNo==0)	return (BYTE)dbGetCharField(Record,"符号1");
   if (SymNo==1)	return (BYTE)dbGetCharField(Record,"符号2");
   if (SymNo==2)	return (BYTE)dbGetCharField(Record,"符号3");
   if (SymNo==3)	return (BYTE)dbGetCharField(Record,"符号4");