function.cpp

Borland c++编写

 #include <stdio.h>
 #include <conio.h>
 #include <math.h>
 #include <stdlib.h>
 #include "htlcd.h"
 #include "htxlcd.h"
 #include "FUNCTION.H"
 #include <string.h>
 #include <process.h>
 #include "commplus.h"
 #include "Infrared.h"
 #include  "time.h"
 #include <dos.h>
 #include "SubFun.h"
 #include "CStream.h"
 #include <stdlib.h>
 
//窃电库
typedef struct {
  char  number[8];               //表号；
  unsigned char  type;           //窃电标识；
  char  st[8];                  //窃电起始时间；
  char  ct[8];                  //窃电终止时间；
} DBF_REC;

//实时库(电表数据)；
typedef struct {
  char number[8];                 //表号；
  char time[6];                   //当前时间；
  char date[6];                   //当前日期；
  char ltdn[8];                   //当前电能；
  char md[6];                     //当前最大需量；
  char glys[4];                   //功率因数；
  // char ljxl[6];                   //累计最大需量；
  char qdcs[2];                   // 窃电次数;
  char axdy[4];                   //A相电压；
  char bxdy[4];                   //B相电压；
  char cxdy[4];                   //C相电压；
  char axdl[4];                   //A相电流；
  char bxdl[4];                   //B相电流；
  char cxdl[4];                   //C相电流；
  //char yggl[6];                 //有功功率；
  char axgl[6];                   //A相有功功率；
  char bxgl[6];                   //B相有功功率；
  char cxgl[6];                   //C相有功功率；
  //char axys[6];                 //A相功率因数；
  // char bxys[6];                //B相功率因数；
  // char cxys[6];                //C相功率因数；
  char dczt[2];                   //电池状态;
 
} DBF_Tss;

//表号库；
typedef struct {
   char bh[8];                    //表号；
   char lx[1];                    //表类型；
}DBF_Tbh;

//连续6个月需量；
typedef struct {
   char bh[8];                    //表号;
   char rq[4];                    //日期;
   char xl[8];		          //需量;
}DBF_TLx;

//连续6个月电能；
typedef struct {
   char bh[8];                    //表号；
   char sj[4];                    //日期；
   char dn[8];                    //电能；
 }DBF_TLd;
 
 //60天电能
typedef struct{
   char number[8];                //表号；
   char datetime[8];              //日期；
   char md1[4];                    //电能；
}DBF_TDn;

typedef struct{
   char balance[4];               //日期，小时
}DBF_Tjs;

extern int ReceiveFileChar(unsigned char &C,int delay);
long fhdsize;
long frcsize;
long reccount;
FILE * fhandle;
struct sdk * find(char * Mc);

DBF_REC dbfitem;
DBF_Tss dbfitem_Tss;
DBF_Tbh dbfitem_Tbh;
DBF_TLd dbfitem_TLd;
DBF_TLx dbfitem_TLx;
DBF_TDn dbfitem_TDn;

void strstore(char *src,char * dest, int len)
{
   int i,j;
   i=strlen(src);
   if (i>len) i=len;
   for (j=0;j<i;j++)
     *dest++=*src++;
     while (j<len)  {
     *dest++=' ';
     j++;
     }
}

//向窃电数据库添加数据；
void AppendRecord (DBF_REC &crecord)
{
  fseek(fhandle,4L,0);
  long recount;
  fread(&recount,sizeof(long),1,fhandle);
  recount++;
  fseek(fhandle,4L,0);
  fwrite(&recount,sizeof(long),1,fhandle);
  fseek(fhandle,-1,2);
  char buff[27];
  buff[0]=0X20;
  memcpy(&buff[1],&crecord,27);
  fwrite(buff,27,1,fhandle);
  fseek(fhandle,0,2);
  buff[0]=0x1A;
  fwrite(&buff[0],1,1,fhandle);
}

//向当前数据库添加数据；
void AppendRecord1 (DBF_Tss &crecord)
{
  fseek(fhandle,4L,0);
  long recount;
  fread(&recount,sizeof(long),1,fhandle);
  recount++;
  fseek(fhandle,4L,0);
  fwrite(&recount,sizeof(long),1,fhandle);
  fseek(fhandle,-1,2);
  char buff1[85];
  buff1[0]=0X20;
  memcpy(&buff1[1],&crecord,85);
  fwrite(buff1,85,1,fhandle);
  fseek(fhandle,0,2);
  buff1[0]=0x1A;
  fwrite(&buff1[0],1,1,fhandle);
}



//向6个月需量库；
void AppendRecord7 (DBF_TLx &crecord)
{
  fseek(fhandle,4L,0);
  long recount;
  fread(&recount,sizeof(long),1,fhandle);
  recount++;
  fseek(fhandle,4L,0);
  fwrite(&recount,sizeof(long),1,fhandle);
  fseek(fhandle,-1,2);
  char buff[21];
  buff[0]=0X20;
  memcpy(&buff[1],&crecord,21);
  fwrite(buff,21,1,fhandle);
  fseek(fhandle,0,2);
  buff[0]=0x1A;
  fwrite(&buff[0],1,1,fhandle);
}

//向6个月电能；
void AppendRecord8 (DBF_TLd &crecord)
{
  fseek(fhandle,4L,0);
  long recount;
  fread(&recount,sizeof(long),1,fhandle);
  recount++;
  fseek(fhandle,4L,0);
  fwrite(&recount,sizeof(long),1,fhandle);
  fseek(fhandle,-1,2);
  char buff[21];
  buff[0]=0X20;
  memcpy(&buff[1],&crecord,21);
  fwrite(buff,21,1,fhandle);
  fseek(fhandle,0,2);
  buff[0]=0x1A;
  fwrite(&buff[0],1,1,fhandle);
}

//60天电能；
void AppendRecord9 (DBF_TDn &crecord)
{
  fseek(fhandle,4L,0);
  long recount;
  fread(&recount,sizeof(long),1,fhandle);
  recount++;
  fseek(fhandle,4L,0);
  fwrite(&recount,sizeof(long),1,fhandle);
  fseek(fhandle,-1,2);
  char buff1[21];
  buff1[0]=0X20;
  memcpy(&buff1[1],&crecord,21);
  fwrite(buff1,21,1,fhandle);
  fseek(fhandle,0,2);
  buff1[0]=0x1A;
  fwrite(&buff1[0],1,1,fhandle);
}

//结算时间

//关闭数据库；
void dbfclose(void)
{
  fclose(fhandle);
}

void beep(int cnt)
{
  int i;

  for (i=0; i<cnt; i++)
    asm {
      mov  ax, 0e07h
      int  10h
    }
}

//数据打印++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int print ( char * prin, int count)
{
  char *tr=new char [count];
  tr[0]=0;
  int k=1;
  while(strlen(prin)!=0)
   {
     memcpy(tr ,prin,count);
     tr[14]=0;
     printf("%d:%s\n",k,tr);
     getch();
     prin+=count;
     k++;
   }
delete [] tr;
return 0;
}


// 电表数据--------------------------------------------------------------
 int dqsj(void)  //当前数据库；
{
  static char * sdbs[]={
  "9010",              //当前电能；
  "A010",              //当前最大需量；
  "B650",              //功率因数；
  "B310",              //窃电次数；
  "B611",              //A相电压；
  "B612",              //B相电压；
  "B613",              //C相电压；
  "B621",              //A相电流；
  "B622",              //B相电流；
  "B623",              //C相电流；
  "B631",              //A相有功功率；
  "B632",              //B相有功功率；
  "B633",              //C相有功功率；；
  "C020",              //电池状态字;
 } ;
 int i,cont;
 char * DataName=new char[6];
 char * Getval = new char[6000];
// char * Addr =new char[8];
 char * sz = new char[12];
 char dq[14][8];
// char sz1[12];
 DataName[0]=0;
// Addr[0]=0;
 dq[0][0]=0;
 Getval[0]=0;
 sz[0]=0;
 i=0;
 cont=0;

//自动读数据；
  clrscr();
  printf("wait...");
  getch();
  strcat(DataName,sdbs[0]);
  i=0;
 unsigned char rtncode;
do
{
   cont=0;
   do
   {
  
  
    rtncode=ReadData(DataName,Getval,sz);
    if (rtncode==0)
     {
	memcpy(&dq[i][0],Getval,strlen(Getval));
	clrscr();
	printf("%s",Getval);
	DataName[0]=0;
	Getval[0]=0;
	sz[0]=0;
	cont=8;
      }
     else {	//错误处理
      cont++;
      }
   } while(cont<3);//do while cont
   if (cont==3)
    {
      clrscr();
     
      printf("%s\n",sdbs[i]);
      printf("error");
      
      int h;
      for (h=0;h<=12-i;h++)
      {
       memcpy (&dq[i+h][0],"FF",8);
      }

      i=18;
      getch();
      return 0;
    }
   else
    {
     i++;
     getch();
     clrscr();
     strcat(DataName, sdbs[i]);
   
    }
  
}while(i<14); //do while i


 fhandle=fopen("d:\\tss.dbf","rb+");      //以可读写方式打开数据库；

 unsigned tmp;
 char fhead[12];
 unsigned hdsize[4];

 fread(fhead,12,1,fhandle);
 memcpy(&hdsize,(unsigned *)&fhead[9],2);
 memcpy(&hdsize[2],(unsigned *)&fhead[8],2);
 memcpy(&fhdsize,hdsize,4);
 frcsize=fhead[10];
 reccount=fhead[4];
 

//取抄表时间
  struct time t ;
  gettime (&t);
  char *shi;
  char *sm;
  char *se;

  if (t.ti_hour<10)
  {
    dbfitem_Tss.time[0]=48;
    shi=itoa(t.ti_hour,shi,10);
    memcpy(&dbfitem_Tss.time[1],shi,1);
  }
  else
  {
   shi=itoa(t.ti_hour,shi,10);
   memcpy(&dbfitem_Tss.time[0],shi,2);
  }

  if (t.ti_min<10)
  {
   dbfitem_Tss.time[2]=48;
   sm=itoa(t.ti_min,sm,10);
   memcpy(&dbfitem_Tss.time[3],sm,1);
  }
  else
  {
   sm=itoa(t.ti_min,sm,10);
   memcpy(&dbfitem_Tss.time[2],sm,2);
  }
  if (t.ti_sec<10)
  {
   dbfitem_Tss.time[4]=48;
   se=itoa(t.ti_min,se,10);
   memcpy(&dbfitem_Tss.time[5],se,1);
  }
  else
  {
   se=itoa(t.ti_sec,se,10);
   memcpy(&dbfitem_Tss.time[4],se,2);
  }
  struct date d ;
  getdate (&d);
  char * p;
  char * p1;
  char * p2;
  p=itoa(d.da_year,p,10);
  p+=2;
  memcpy(&dbfitem_Tss.date[0],&p[0],2 );
  if (d.da_mon<10)
  {
   p1=itoa(d.da_mon,p1,10);
   dbfitem_Tss.date[2]=48;
   memcpy(&dbfitem_Tss.date[3],p1,1);
  }
  else
  {
   p1=itoa(d.da_mon,p1,10);
   memcpy(&dbfitem_Tss.date[2],p1,2);
  }
  if (d.da_day<10)
  {
   p2=itoa(d.da_day,p2,10);
   dbfitem_Tss.date[4]=48;
   memcpy(&dbfitem_Tss.date[5],p2,1);
  }
  else
  {
   p2=itoa(d.da_day,p2,10);
   memcpy(&dbfitem_Tss.date[4],p2,2);
  }

  memcpy(dbfitem_Tss.number,&sz[4],8);
  memcpy(&dbfitem_Tss.ltdn,&dq[0][0],8);
  memcpy(&dbfitem_Tss.md,&dq[1][0],6);
  memcpy(&dbfitem_Tss.glys,&dq[2][0],4);
  memcpy(&dbfitem_Tss.qdcs,&dq[3][0],2);
  memcpy(&dbfitem_Tss.axdy,&dq[4][0],4);
  memcpy(&dbfitem_Tss.bxdy,&dq[5][0],4);
  memcpy(&dbfitem_Tss.cxdy,&dq[6][0],4);
  memcpy(&dbfitem_Tss.axdl,&dq[7][0],4);
  memcpy(&dbfitem_Tss.bxdl,&dq[8][0],4);
  memcpy(&dbfitem_Tss.cxdl,&dq[9][0],4);
  memcpy(&dbfitem_Tss.axgl,&dq[10][0],6);
  memcpy(&dbfitem_Tss.bxgl,&dq[11][0],6);
  memcpy(&dbfitem_Tss.cxgl,&dq[12][0],6);
  memcpy(&dbfitem_Tss.dczt,&dq[13][0],2);
  AppendRecord1(dbfitem_Tss);
  getch();

 delete []DataName;
 delete []Getval;
 delete []sz;
 delete []dq;
 dbfclose();
 clrscr();
 return 0;
}

//读窃电***********************************************************
int qdsj(int yxm)
{
    clrscr();
    fhandle=fopen("tqd.dbf","rb+");
    char fhead[12];
    fread(fhead,12,1,fhandle);
    fhdsize=fhead[8];
    frcsize=fhead[10];
    reccount=fhead[4];

    char * Getval = new char[6000];
    char * tr=new char [10];
    char * address=new char[12];
    char * p;
    int i;
    char str[3];
    char DTStr[3];
    char qd[500];
    int t;
    char cbmonth[2];
    char * DataName=new char[6];
    char * sz=new char [12];


    Getval[0]=0;
    DataName[0]=0;
    sz[0]=0;
    tr[0]=0;
    address[0]=0;
    qd[0]=0;
 //   q=0;
    
   
    printf("%s","wait...");
    getch();

    struct date d ;
    getdate (&d);

  if (yxm==0)
   {
    t=d.da_mon;
    strcat(DataName, "D320");

   }
  if (yxm==1)
   {
    if (d.da_mon==1)
     {
      t = 12;
     }
    else t=d.da_mon-1;
    strcat(DataName, "D321");
   }
  if (yxm==2)
   {
     if (d.da_mon==2)
      {
       t=12;
      }
     else if (d.da_mon==1)
      {
	t=11;
      }
     else t=d.da_mon-2;
     strcat(DataName, "D322");
   }