hexpp.cpp

基本实现单片机和PC机的通信

#include"hexpp.h"

__fastcall hexcom::hexcom():TComponent(Owner)        //构造函数
	{
		   ReceivedSP=0;
		   eventok=1;
			 last=0;
			 ACKflag=0;
       Myaddr=0;
       time2=new TTimer(this);         //超时响应定时
       time2->Enabled=false;
       time2->Interval=100;
       time2->OnTimer=proctime2;
         
       unsigned int i;
			 lastSP=new eventcircle;
			 headSP=lastSP;
			 for(i=0;i<100;i++){
				lastSP->next=new eventcircle;
				lastSP=lastSP->next;
			 }
			 lastSP->next=headSP;
			 lastSP=headSP;
	}
	
//----------------------------------------------------------------------------------	

void hexcom::opencom(int portnum,int baudrate)    //开启串口
	{
		char *ComNo;
    DCB dcb;
    String Temp;
    Temp="COM"+IntToStr(portnum);
    ComNo=Temp.c_str();
    hComm=CreateFile(ComNo,GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,0);
    if(hComm==INVALID_HANDLE_VALUE)
    {
    MessageBox(0,"串口打开失败","串口打开失败",MB_OK);
    return;
    }
    GetCommState(hComm,&dcb);
    dcb.BaudRate=baudrate;
    dcb.ByteSize=8;
    dcb.Parity=3;
    dcb.StopBits=0;
    if(!SetCommState(hComm,&dcb)){
    MessageBox(0,"串口设置失败","串口设置失败",MB_OK);
    CloseHandle(hComm);
    return;
    }
	  }

//------------------------------------------------------------------------------------------- 
 void hexcom::closecom(){                       //关闭串口
CloseHandle(hComm);
}
//--------------------------------------------------------------------------------------------
      int hexcom::startdata(){                 //发送数据请求 WorR='R'时发送读请求
      if(WorR=='R') return sendrdata();      	      
      	else {
      		eventtemp.comnum=thecomnum;
      		(*eopsp)(&eventtemp,2);
      		return  sendwdata();
      	}
      } 
//--------------------------------------------------------------------------------------------      
       
      void hexcom::getevent(eventcircle *a)      //取得事件
      	{ 
      		lastSP->comnum=a->comnum;
      		lastSP->Addr=a->Addr;
      		lastSP->eWorR=a->eWorR;
      		lastSP->DataType=a->DataType;
      	  lastSP->DataAddr=a->DataAddr;
      	  lastSP->DataNum=a->DataNum;
      	  lastSP->OTnum=a->OTnum;
      	  lastSP->opsp=a->opsp;
      	  lastSP=lastSP->next;
      	}

//--------------------------------------------------------------------------------------------

     float hexcom::getfloatD(unsigned char n)     //取得一个浮点数
     {
     	union Fdata f;
     	f.FByteD[0]=RXdata[2+n*4];
     	f.FByteD[1]=RXdata[3+n*4];
     	f.FByteD[2]=RXdata[4+n*4];
     	f.FByteD[3]=RXdata[5+n*4];
     	return f.FloatD;
    }
    
//--------------------------------------------------------------------------------------------
    unsigned int hexcom::getintD(unsigned char n)    //取得一个字
    {
    	union Wdata w;
    	w.WByteD[0]=RXdata[2+n*2];
    	w.WByteD[1]=RXdata[3+n*2];
    	return w.WordD;
    }
//--------------------------------------------------------------------------------------------    
    
     int hexcom::sendaddr(unsigned char addr)          //合成地址请求
	  {
		unsigned char crc=0x05;
		TXdata[0]=0x05;
		TXdata[1]=addr;
		crc^=addr;
		TXdata[2]=0x04;
		crc^=0x04;
    TXdata[3]=crc;
		Step=1;
    return 4;
	  }
 
//---------------------------------------------------------------------------------------------- 
	   unsigned char hexcom::getbyte(unsigned char a)     //从串口接受数据并进行协议处理
	   { 
	   	unsigned char i,n;
		   if(last==ACK&&ACKflag==0){
			   ReceivedSP=0;
			   ACKflag=1;
			   rcrc=ACK;
		   }
		   rcrc^=a;
		   RXdata[ReceivedSP]=a;
           ReceivedSP++;
		   if(last==ETX&&rcrc==0){
			   last=a;
			   if(Step==1&&ReceivedSP==3&&RXdata[0]==Myaddr){
			   	ACKflag=0;
			   	return 1;
			  }
			   if(Step==2&&ReceivedSP==ReadNum+4){
			   	ACKflag=0;
			   	switch(ReadType){
			   		case DF:{
			   			n=ReadNum/4;
			   			for(i=0;i<n;i++)FLOATdata[i]=getfloatD(i);
			   		}
			   		case DW:{
			   		  n=ReadNum/2;
			   		  for(i=0;i<n;i++)WORDdata[i]=getintD(i);
			   		}
			   		case DB:{
			   		  for(i=0;i<ReadNum;i++)BYTEdata[i]=RXdata[2+i];
			   		}
			   	}
			   	
 			    return 2;
			    }
			   if(Step==3&&ReceivedSP==3&&RXdata[0]==0)
			   	{
			   		
			   		return 3;
			   	}			                        
		   }
		   
         last=a;
			   return 0;
		   
	   }
//------------------------------------------------------------------------------------------
int hexcom::sendrdata()                 //合成数据读请求
	{
		union Wdata addr;
		unsigned char crc=ENQ;
		TXdata[0]=ENQ;
		TXdata[1]='R';
		crc^='R';
		TXdata[2]=ReadType;
		crc^=ReadType;
		addr.WordD=TempAddr;
		TXdata[3]=addr.WByteD[0];
		crc^=addr.WByteD[0];
		TXdata[4]=addr.WByteD[1];
		crc^=addr.WByteD[1];
		TXdata[5]=ReadNum;
		crc^=ReadNum;
		TXdata[6]=EOT;
		crc^=EOT;
		TXdata[7]=crc;
		Step=2;
		return 8;
	}

//-------------------------------------------------------------------------------------------		
int hexcom::sendwdata()                    //合成数据写请求
	{
		union Wdata addr;
		unsigned char crc=ENQ,i=5;
		TXdata[0]=ENQ;
		TXdata[1]='W';
		crc^='W';
		TXdata[2]=ReadType;
		crc^=ReadType;
		addr.WordD=TempAddr;
		TXdata[3]=addr.WByteD[0];
		crc^=addr.WByteD[0];
		TXdata[4]=addr.WByteD[1];
		crc^=addr.WByteD[1];
		
		
		switch (ReadType){
			case DB:{
				TXdata[i]=BYTEdata[0];
				crc^=BYTEdata[0];
				i++;
			}break;
			case DW:{
				union Wdata wd;
				wd.WordD=WORDdata[0];
				TXdata[i]=wd.WByteD[0];
				crc^=wd.WByteD[0];
				TXdata[i]=wd.WByteD[1];
				crc^=wd.WByteD[1];
				i=i+2 ;
			}break;
			case DF:{
				union Fdata fd;
				fd.FloatD=FLOATdata[0];
				TXdata[i]=fd.FByteD[0];
				crc^=fd.FByteD[0];
				//i++;
				TXdata[i]=fd.FByteD[1];
				crc^=fd.FByteD[1];
				//i++;
				TXdata[i]=fd.FByteD[2];
				crc^=fd.FByteD[2];
				//i++;
				TXdata[i]=fd.FByteD[3];
				crc^=fd.FByteD[3];
			i=i+4;
			}break;
		}
		
		
		TXdata[i]=EOT;
		i++;
		crc^=EOT;
		TXdata[i]=crc;
		Step=3;
		return i+1;
	}
//--------------------------------------------------------------------------------------------	
	
//--------------------------------------------------------------------------------------------

		void __fastcall hexcom::proctime2(TObject *Sender)            //超时处理
			{ time2->Enabled=false;
				ACKflag=0;				
				if(outtimenum>0){
				outtimenum--;
				lastSP->Addr=Myaddr;
      	lastSP->eWorR=WorR;
      	lastSP->DataType=ReadType;
      	lastSP->DataAddr=TempAddr;
      	lastSP->DataNum=ReadNum;
      	lastSP->OTnum=outtimenum;
      	lastSP->opsp=eopsp;
      	lastSP=lastSP->next;      	
				}
				else{
					eventtemp.comnum=thecomnum;
					(*eopsp)(&eventtemp,0);//________________________________________________
					}
				eventok=1;
			}
			
//---------------------------------------------------------------------------------------------			
			void hexcom::startchange()                       // 开启一次数据交换
				{
				DCB dcb;
        char *sp;
        unsigned long lrc;
        GetCommState(hComm,&dcb);
        dcb.Parity=3;
        SetCommState(hComm,&dcb);
        dcb.Parity=4;
        sp=TXdata;
        WriteFile(hComm,sp,sendaddr(Myaddr),&lrc,NULL);
        SetCommState(hComm,&dcb);
        time2->Enabled=TRUE;
        eventok=0;	        
				}