serport.cpp

101通讯规约代码,实现和数据库的完整对接,采用多线程多任务开发.

// SerPort.cpp: implementation of the C101Port class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
//#include "AnCom.h"
#include "SerPort.h"
#include <io.h>

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

C101Port::C101Port()
{
	m_hIDComDev = NULL;
	m_bOpened = FALSE;
	memset(&m_osRead,0,sizeof(OVERLAPPED));
	memset(&m_osWrite,0,sizeof(OVERLAPPED));

	memset(&m_osWaitComm,0,sizeof(OVERLAPPED));
}

C101Port::~C101Port()
{
	Close();

}

BOOL C101Port::Open( int nPort, int nBaud )
{
	m_nBufferLoc= 0;

	if( m_bOpened )
		return TRUE;

	char szPort[15];
	wsprintf( szPort, "COM%d", nPort );
    m_hIDComDev = CreateFile( szPort, GENERIC_READ | GENERIC_WRITE,
                     0,                    // exclusive access
                     NULL,                 // no security attrs
                     OPEN_EXISTING,
                     FILE_ATTRIBUTE_NORMAL 
					 | FILE_FLAG_OVERLAPPED, // overlapped I/O
                     NULL );

	if( m_hIDComDev == (HANDLE) -1 )
	{
		MessageBeep(MB_ICONQUESTION);
		wsprintf( szPort, "COM%d Open failure!", nPort );
		MessageBox(NULL,szPort,"Error message",MB_OK|MB_ICONERROR);
		return FALSE ;
	}
    COMMTIMEOUTS  CommTimeOuts ;
    CommTimeOuts.ReadIntervalTimeout = 0xFFFFFFFF ;
    CommTimeOuts.ReadTotalTimeoutMultiplier = 1 ;
    CommTimeOuts.ReadTotalTimeoutConstant = 1000 ;
    CommTimeOuts.WriteTotalTimeoutMultiplier =0; /*2*CBR_9600/nBaud;*/
    CommTimeOuts.WriteTotalTimeoutConstant = 1000 ;
    SetCommTimeouts( m_hIDComDev, &CommTimeOuts ) ;
//**********************************************************************
   BYTE       bSet ;
   DCB        dcb ;

   dcb.DCBlength = sizeof( DCB ) ;
   GetCommState( m_hIDComDev , &dcb ) ;

   dcb.BaudRate = nBaud ;
   if(nPort ==2)
	dcb.ByteSize = 7;
   else
	dcb.ByteSize = 8;
   dcb.Parity = /*ODDPARITY;//*/NOPARITY ;
   dcb.StopBits = ONESTOPBIT ;

   bSet = (BYTE) ((FC_XONXOFF & FC_DTRDSR) != 0) ;// the FC_XONXOFF is user define
   dcb.fOutxDsrFlow = bSet ;
   if (bSet)
      dcb.fDtrControl = DTR_CONTROL_HANDSHAKE ;
   else
      dcb.fDtrControl = DTR_CONTROL_ENABLE ;

   bSet = (BYTE) ((FC_XONXOFF & FC_RTSCTS) != 0) ;
   dcb.fOutxCtsFlow = bSet ;
   if (bSet)
      dcb.fRtsControl = RTS_CONTROL_HANDSHAKE ;
   else
      dcb.fRtsControl = RTS_CONTROL_ENABLE ;

   bSet = (BYTE) ((FC_XONXOFF & FC_XONXOFF) != 0) ;//the first FC_XONXOFF is user define

   dcb.fInX = dcb.fOutX = bSet;
   dcb.XonChar = ASCII_XON ;
   dcb.XoffChar = ASCII_XOFF ;
   dcb.XonLim = 100 ;
   dcb.XoffLim = 100 ;

   // other various settings
   dcb.fBinary = TRUE ;
   dcb.fParity = TRUE ;

   m_bOpened = SetCommState( m_hIDComDev, &dcb ) ;
   if(m_bOpened)
   {
	//*******************************************************************
		// get any early notifications
		SetCommMask(m_hIDComDev, EV_RXCHAR ) ;
		// setup device buffers
		SetupComm(m_hIDComDev, 1024, 1024 ) ;
		// purge any information in the buffer
		PurgeComm(m_hIDComDev, PURGE_TXABORT | PURGE_RXABORT |
										  PURGE_TXCLEAR | PURGE_RXCLEAR ) ;
	//**********************************************************************
	   // create I/O event used for overlapped reads / writes
	  HANDLE	handle1=NULL,handle2=NULL,handle3=NULL;
	   handle1 = CreateEvent( NULL,    // no security
									  TRUE,    // explicit reset req
									  FALSE,   // initial event reset
									  NULL ) ; // no name
	   handle2 = CreateEvent( NULL,    // no security
									  TRUE,    // explicit reset req
									  FALSE,   // initial event reset
									  NULL ) ; // no name
	   handle3 = CreateEvent( NULL,    // no security
									  TRUE,    // explicit reset req
									  FALSE,   // initial event reset
									  NULL ) ; // no name
	   if(!handle1 || !handle2 || !handle3)
	   {
		  CloseHandle(handle1 ) ;
		  CloseHandle(handle2 ) ;
		  CloseHandle(handle3 ) ;
		  return FALSE;
	   }
	   m_osRead.hEvent = handle1;
	   m_osWrite.hEvent = handle2;
	   m_osWaitComm.hEvent = handle3;
   }
   return m_bOpened ;
}

BOOL C101Port::Close()
{
	if(!m_bOpened && !m_hIDComDev)
		return TRUE;
    SetCommMask( m_hIDComDev, 0 ) ;
    EscapeCommFunction( m_hIDComDev, CLRDTR ) ;
    // purge any outstanding reads/writes and close device handle
    PurgeComm( m_hIDComDev, PURGE_TXABORT | PURGE_RXABORT |
                                   PURGE_TXCLEAR | PURGE_RXCLEAR ) ;
	if(m_osRead.hEvent)
		CloseHandle(m_osRead.hEvent);
	if(m_osWrite.hEvent)
		CloseHandle(m_osWrite.hEvent);
	if(m_osWaitComm.hEvent)
		CloseHandle(m_osWaitComm.hEvent);
   CloseHandle(m_hIDComDev) ;
   return  TRUE;
}

LPSTR C101Port::CombinationCommand(BYTE *temp,int length)
{
	//Add by xzp.2007-2-2
	LPSTR tempArr="";
	int length1 = 0;
	tempArr += char(68);
	tempArr += char(length1);
	tempArr += char(length1);
	tempArr += char(68);
	//BYTE temp1[]={100,111,112,114,115};
	//BYTE buf[]={100,1,6,1,0,0,21};
	for(int i = 0;i< sizeof(temp);i++){
		tempArr += char(temp[i]);
	}
	AfxMessageBox(tempArr);
	tempArr += char(16);
	return tempArr;
}

BYTE C101Port::crc8(BYTE *chkchar, int chklong)
{
	//BYTE *str,crcval,cgx8,a,temp,acc0,r0;
    //BYTE buf[]={100,1,6,1,0,0,21};//Type,Informationbody num,COT,ASDU address
	int i = 0;
	BYTE tempBuf,tempCrcBuf = 0;
	for(i = 0;i < sizeof(chkchar);i++)
	{
		tempBuf += chkchar[i];

	}
	tempBuf = tempBuf % 0xFF;
	//Only caculate CRC.Add by xzp 2007-2-2
    /*
	CString mstr;
	mstr.Format("chkchar[0]: %2x",chkchar[0]);
    MessageBox(mstr);
	mstr.Format("chkchar[1]: %2x",chkchar[1]);
    MessageBox(mstr);
	mstr.Format("chkchar[2]: %2x",chkchar[2]);
    MessageBox(mstr);
	mstr.Format("chkchar[3]: %2x",chkchar[3]);
    MessageBox(mstr);
	mstr.Format("chkchar[4]: %2x",chkchar[4]);
    MessageBox(mstr);
	mstr.Format("chklong: %2x",chklong);
    MessageBox(mstr);
	mstr.Format("gx8: %3x",gx8);
    MessageBox(mstr);
	*/

    /*str = (char *) malloc(chklong+1);
    for (i=0;i<chklong;i++)
       str[i]=chkchar[i];
    str[chklong]=0;
    cgx8=(char)gx8 & 0x0ff;
 
	acc0=0;
    r0=0;
    chklong++;

	for (iloop=0;iloop<chklong;iloop++)
	{
       a=str[iloop];
       byte=8;
	   for (ibyte=byte; ibyte>0;ibyte--)
	   {
		   temp=a & 0x80;
           a=a<<1;
           acc0=r0 & 0x80;
           r0=r0<<1;
           if(temp !=0)
			   r0=r0|0x1;
           if(acc0 !=0)
			   r0=r0^cgx8;
	   }
	}
    crcval=r0;
    free(str);
    crcval=~crcval;*/
	return tempBuf;
}
BOOL C101Port::Write(LPSTR lpByte , DWORD dwBytesToWrite )
{
	BOOL     fWriteStat ;
	DWORD    dwBytesWritten ;
	DWORD    dwErrorFlags;
	COMSTAT  ComStat;
	char     szError[128] ;
	fWriteStat = WriteFile(m_hIDComDev,lpByte,dwBytesToWrite,&dwBytesWritten,&m_osWrite);

	if(!fWriteStat)
	{
		if(GetLastError() == ERROR_IO_PENDING)
		{
			while(!GetOverlappedResult(m_hIDComDev,&m_osWrite,&dwBytesWritten,TRUE))
			{
				if(GetLastError() == ERROR_IO_INCOMPLETE)
					continue;
				else
				{
				   ClearCommError(m_hIDComDev,&dwErrorFlags,&ComStat);
				   break;
				}
			}
		}
		else
		{
			ClearCommError(m_hIDComDev,&dwErrorFlags,&ComStat);
			MessageBeep(MB_ICONQUESTION);
			wsprintf( szError,"串口发送数据出错!\n\n错误号-%u",dwErrorFlags);
			MessageBox (NULL,szError,"错误信息",MB_OK|MB_ICONERROR);
			return FALSE;
		}
	}


  if (dwBytesWritten != dwBytesToWrite) 
	::MessageBox (NULL,"error,test,no send comp!","错误信息",MB_OK|MB_ICONERROR);

   return TRUE ;
}


BOOL Combitioncmd(const char* pData, int nData, float* result, bool* pative, bool* weightover)
{
	char number_char[9];
	number_char[8]= '\0';
	float fResult= 0;
//	int nResult= 0;
//	BYTE flag= 0;
	if(pData[0] == 0x4e)
	{
		
		switch(nData)
		{
		case 20:
			::memcpy(number_char,pData+8, 8);
			fResult= atoi(number_char);
			if(pData[6] == 0x2d){
				float ctm=0;
				ctm=-fResult;
				fResult=ctm;
			}
			else{
				//Add 
			}		
			break;
		default:
			return FALSE;
			break;
		}
		*result= fResult;
	
	}else if(pData[0] == 0x53){
		if(pData[12] == 0x4c){
			fResult=-9999;
			*result= fResult;
		
		}
		if(pData[12] == 0x48){
			fResult=9999;
			*result= fResult;
			
		}

	}else
		return FALSE;
	return TRUE;
}
extern float m_ReadData;
void C101Port::UpdateDatabase(const char* pData, int nData)
{
	{
		::memcpy(m_BufferData+m_nBufferLoc, pData, nData);
		m_nBufferLoc += nData;
	}
	if(m_nBufferLoc >= 39)
	{
		int loc= -1,locs=-1;
		for(int i=0; i<m_nBufferLoc; i++)
		{
			if(m_BufferData[i] == 0x4e)
			{
				if(loc>=0)
				{
					if(i-loc==22)
					{
						if(!Combitioncmd(m_BufferData + loc, 20, &m_ReadData, NULL, NULL))
						{
							i= i;
						}
					}
					::memcpy(m_BufferData,  m_BufferData + i-1, m_nBufferLoc-i);
					m_nBufferLoc= 0;
				}
				loc= i;
			}
			if(m_BufferData[i] == 0x53)
			{
				if(locs>=0)
				{
					if(i-locs==22)
					{
						if(!Combitioncmd(m_BufferData + locs, 20, &m_ReadData, NULL, NULL))
						{
							i=i;
						}
					}
					::memcpy(m_BufferData,  m_BufferData + i-1, m_nBufferLoc-i);
					m_nBufferLoc= 0;
				}
				locs=i;
			}			
		}
		m_nBufferLoc= 0;
	}
}

int C101Port::Read( LPSTR lpszBlock, int nMaxLength )
{
	BOOL       fReadStat ;
	COMSTAT    ComStat ;
	DWORD      dwErrorFlags;
	DWORD      dwLength;
	char       szError[128] ;

	// only try to read number of bytes in queue
	ClearCommError(m_hIDComDev,&dwErrorFlags,&ComStat);
//	if( !ComStat.cbInQue ) 
//		return 0;
	dwLength = min((DWORD)nMaxLength,ComStat.cbInQue);

	if(dwLength >0)
	{
		fReadStat = ReadFile(m_hIDComDev, lpszBlock,dwLength, &dwLength,&m_osRead);
		if(!fReadStat)
		{
			if(GetLastError() == ERROR_IO_PENDING)
			{
				while(!GetOverlappedResult(m_hIDComDev,&m_osRead,&dwLength,TRUE))
				{
				   if(GetLastError() == ERROR_IO_INCOMPLETE)
					  continue; // normal result if not finished
				}
			}
			else
			{
				dwLength =0;
				ClearCommError(m_hIDComDev,&dwErrorFlags,&ComStat);
				MessageBeep(MB_ICONQUESTION);
	            wsprintf(szError,"串口接受数据出错!\n\n错误号-%u",dwErrorFlags);
				MessageBox(NULL,szError,"错误信息",MB_OK|MB_ICONERROR);
			}
		}
	}
 
   return dwLength ;
}

DWORD C101Port::GetSerMask()
{
int i= 0;

	DWORD dwEvtMask= 0;
	(m_osRead).Internal= 0;
	(m_osRead).InternalHigh=0;
	(m_osRead).Offset=0;
	(m_osRead).OffsetHigh= 0;
//	WaitCommEvent(m_hIDComDev,&dwEvtMask,NULL);//&m_osRead);
	if(!WaitCommEvent(m_hIDComDev,&dwEvtMask,&m_osRead))//m_osWaitComm
	{
		if(GetLastError() == ERROR_IO_PENDING)
		{
			if (WaitForSingleObject( m_osRead.hEvent, 1200 ) == WAIT_OBJECT_0)
			{
				DWORD dwLength= 0;
				if(GetOverlappedResult(m_hIDComDev,&m_osRead,&dwLength,TRUE))
					i=i;
				else
					i=i;
			}
			else
				i=i;
//				dwEvtMask= EV_RXCHAR;
		}
		else
			i=i;
	}
	else
	{
		i=i;
	}
	return dwEvtMask;
}

BOOL C101Port::SetSerMask (DWORD dwEvtMask)
{
	return SetCommMask(m_hIDComDev,dwEvtMask);
}

void C101Port::ClearInBuf()
{
	PurgeComm(m_hIDComDev,PURGE_RXCLEAR);
}