reg.cpp

DCOM 上位机和嵌入式系统通信

// reg.cpp : Implementation of Creg
#include "stdafx.h"
#include "ComServer.h"
#include <windows.h>
#include <stdio.h>
#include "reg.h"

/////////////////////////////////////////////////////////////////////////////
// Creg

BYTE regm[24];

STDMETHODIMP Creg::getRegsource(int basecode, BYTE *regsourc, short *rb)
{
	// TODO: Add your implementation code here
  unsigned char hds[20];
  SYSTEMTIME pdt;
  int ltm,i;
  char tm[4];

     hds[0]=0;
     if(!readhd(hds))
	 {
		*rb=1;
	    return S_OK;
	 }
   	 GetLocalTime(&pdt);
     ltm=pdt.wMilliseconds;
	 getregsour(basecode,ltm,hds,regm);
     for(i=0;i<24;i++)
	 {
		 if(regm[i]>9) 
			 regsourc[i]=regm[i]+0x37;
		 else
			 regsourc[i]=regm[i]+0x30;
	 }
	 
     Files.softNo=basecode;
	 tm[3]=0;
	 for(i=0;i<3;i++)
		 tm[i]=regsourc[23-i];
     HKEY hk = HKEY_CURRENT_USER;
     RegSetValue(hk,"tdcari",REG_SZ,tm,sizeof(tm));
	 *rb=0;
	return S_OK;
}

STDMETHODIMP Creg::setReg(LPSTR regdest, short *rb)
{
	// TODO: Add your implementation code here
  int i;
    for(i=0;i<24;i++)
	  Files.regcode[i]=regdest[i];
	*rb=0;
	return S_OK;
}

STDMETHODIMP Creg::Regcheck(short *rb)
{
	// TODO: Add your implementation code here
    if(checkRegcode())
	{
		demosys=0;
		*rb=1;
	}else{
		demosys=1;
		*rb=0;
	}
	return S_OK;
}

bool Creg::getsourc(unsigned char *regcode)
{
  unsigned char hds[20];
  int softNo,i;
  HKEY rhk;
  char tm[4];
  long lt;
 // BYTE regm[24];

  hds[0]=0;
     if(!readhd(hds)) return 0;
  softNo=Files.softNo;
  HKEY hk = HKEY_CURRENT_USER;
  if(RegOpenKey(hk,"tdcari",&rhk)!=ERROR_SUCCESS) return 0;
  RegQueryValue(hk,"tdcari",tm,&lt);
  RegCloseKey(hk);
  for(i=0;i<3;i++)
  {
	  if(tm[i]>0x40)
		  tm[i]-=0x37;
	  else
		  tm[i]-=0x30;
  }
  lt=tm[2]*256+tm[1]*16+tm[0];
  getregsour(softNo,lt,hds,regcode);
  return 1;
}

bool Creg::checkRegcode()
{
  int i;
  BYTE newreg[24];
  BYTE low,mid,hig;

  if(getsourc(regm)==0) return 0;
  low=(~regm[23])&0xf;
  mid=(~regm[22])&0xf;
  hig=(~regm[21])&0xf;
  for(i=0;i<8;i++)
  {
	 regm[i]^=low;
	 regm[i+8]^=hig;
	 if(i<6) regm[i+16]^=mid;
  }
  for(i=0;i<8;i++)
  {
	  newreg[i]=regm[8+i];
	  newreg[i+15]=regm[i];
	  if(i<5) newreg[i+9]=regm[i+16];
  }
  newreg[8]=hig;
  newreg[14]=mid;
  newreg[23]=low;
  for(i=0;i<24;i++)
  {
	  if(newreg[i]>9)
		  newreg[i]+=0x37;
	  else
		  newreg[i]+=0x30;
  }
  i=0;
  while((i<24)&&(Files.regcode[i]==newreg[i]))
	  i++;
  if(i<24)
	  return 0;
  else
      return 1;
}

void Creg::getregsour(int softNo,int tmm,unsigned char *hdm,unsigned char *regcode)
{
  int i,j;
  char tm[3];
  BYTE low,mid,hig,tcp,tep;
  long minesum,hdsum,tp,tmp;

     low=tmm & 0xf;
	 if(low==0) 
		tep=1; 
	 else
		tep=low;
     for(i=0;i<5;i++)
	 {
		 tcp=softNo & 0xf;
		 tcp^=tep;
		 regcode[20-i]=tcp;
		 softNo>>=4;
	 }
     mid=(tmm>>4) & 0xf;
	 if(mid==0) 
		tep=2; 
	 else
		tep=mid;
	 minesum=0;
     for(i=0;i<15;i++)
	 {
	     tp=0;
		 for(j=0;j<4;j++)
		 {
		   tmp=Files.mine_name[4*i+j];
		   tp|=tmp<<(24-8*j);
		 }
         minesum+=tp;
	 }
	 for(i=0;i<8;i++)
	 {
		 tcp=minesum & 0xf;
		 tcp^=tep;
		 regcode[15-i]=tcp;
		 minesum>>=4;
	 }
	 hig=(tmm>>8) & 0xf;
	 if(hig==0) 
		tep=3; 
	 else
		tep=hig;
	 hdsum=0;
     for(i=0;i<5;i++)
	 {
	     tp=0;
		 for(j=0;j<4;j++)
		 {
		   tmp=hdm[4*i+j];
		   tp|=tmp<<(24-8*j);
		 }
         hdsum+=tp;
	 }
	 for(i=0;i<8;i++)
	 {
		 tcp=hdsum & 0xf;
		 tcp^=tep;
		 regcode[7-i]=tcp;
		 hdsum>>=4;
	 }
	 regcode[21]=hig;
	 regcode[22]=mid;
	 regcode[23]=low;
  return;
}

unsigned char Creg::inportb(unsigned short p)
{
  unsigned long v = 0;
  GetPortVal(p, &v, 1);
  return v;
}
//---------------------------------------------------------------------------
unsigned short Creg::inportw(unsigned short p)
{
  unsigned long v = 0;
  GetPortVal(p, &v, 2);
  return v;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
void Creg::outportb(unsigned short p, unsigned char v)
{
  SetPortVal(p,v,1);
}

char Creg::DetectHDD(unsigned long BasePort) //bit 0: HDD-0, Bit 1: HDD-1
{
  int HD_No, HD_Detected=0, i, f;
  unsigned char HD_Selection[2]={0xa0,0xb0}; // C:1010 0000, D:1011 0000

  for(HD_No=0; HD_No<=1; HD_No++)
   {
     f=0;
     for(i=0;i<300;i++) //Get HDD Status, wait until HDD not busy
      {
        if((inportb(BasePort+7)&0x80)==0)
         {
           f=1;
           break;
         }
        Sleep(2);
      }
     if(!f)continue;

     outportb(BasePort+6, HD_Selection[HD_No]); //0# HDD Drive/Head Register
     outportb(BasePort+7, 0x10);                //0# HDD Status, Head back to Track 0

     f=0;
     for(i=0;i<300;i++) //Get HDD Status, wait until HDD not busy
      {
        if((inportb(BasePort+7)&0x80)==0)
         {
           f=1;
           break;
         }
        Sleep(2);
      }
     if(!f)continue;

     if(inportb(BasePort+7)==0x50) // HDD ready: 0101 0000
      {
        HD_Detected|=(1<<HD_No);
      }
   }
  return HD_Detected;
}
//---------------------------------------------------------------------------
int Creg::GetHDDInfo(TIDE_ID_Inf *Info, char DriveNo, unsigned int BasePort) //DriveNo ... 0:C, 1:D
{
  unsigned int i=0;
  int Err=0;

  if(DriveNo==0)
    outportb(BasePort+6, 0xa0); //select drive C:
  else
    outportb(BasePort+6, 0xb0); //select drive D:
  outportb(BasePort+7, 0xec);  //read HDD Info

  while(inportb(BasePort+7)!=0x58) //0# HDD Status, wait for R/W ready 0101 0000
   {
     if(i>=300)
      {
        Err=1;
        break;
      }
     Sleep(10);
     i++;
   }

  if(!Err)
   for(i=0;i<=255;i++)
    Info->w[i]=inportw(BasePort);
  return Err;
}

bool Creg::readhd(unsigned char *hd)
{
  char HardDiskDetected; //bit 0:master, bit 1:slave
  unsigned char hds[20];
  //unsigned char hdsub[15]={0x54,0x44,0x43,0x41,0x52,0x49,0x54,0x44,0x43,0x41,0x52,0x49,0x54,0x44,0x43};
  TIDE_ID_Inf IDE_Info;
  bool rb=0;
    bool bl=InitializeWinIo();
    if(bl)
	{
       HardDiskDetected=DetectHDD(IDE1_Port);
       if(HardDiskDetected & 1)
       {
       //  Beep(500,750);
         if(GetHDDInfo(&IDE_Info, 0, IDE1_Port)==0)
		 {
		    for(int i=0;i<10;i++)
			{
			 hds[2*i]=IDE_Info.Serial[i]>>8;
			 hds[2*i+1]=IDE_Info.Serial[i]&0xff;
			}
            rb=1;
		 }else rb=0;
       }
      ShutdownWinIo();
	  if(rb==1)
	  {
	      for(int i=0;i<20;i++)
		    hd[i]=hds[i];
	  }
	}
	return rb;
}

STDMETHODIMP Creg::getNosrc(int *no, BYTE *regym)
{
	// TODO: Add your implementation code here
	int i;
    *no=Files.softNo;
	for(i=0;i<24;i++)
	  regym[i]=regm[i];
	
	return S_OK;
}

/////////////////////////////////////////////////////////////////////////////
// Creg


STDMETHODIMP Creg::getRsource(BYTE *regsourc,short *rb)
{
	// TODO: Add your implementation code here
	 if(getsourc(regm))
	 {
       for(int i=0;i<24;i++)
	   {
		 if(regm[i]>9) 
			 regsourc[i]=regm[i]+0x37;
		 else
			 regsourc[i]=regm[i]+0x30;
		 *rb=0;
	   }
	 }else  *rb=1;
	 
	return S_OK;
}

STDMETHODIMP Creg::ifregister(short *rb)
{
	// TODO: Add your implementation code here
    if(!demosys)
		*rb=1;
	else
		*rb=0;
	return S_OK;
}