www.pudn.com > LoadMachineCode111.rar > communication.cpp

#include "stdafx.h" 
#include "communication.h" 
CComStatus::CComStatus() 
{ 
	m_hCom = NULL; 
	m_bComId = 1;//COM1 
 
	m_bByteSize=8; 
	m_bStopBits=ONESTOPBIT; 
	m_bParity=NOPARITY; 
 
	m_dwBaudRate=9600; 
	m_fBinary=1; 
} 
CComStatus::CComStatus(BYTE bComId,BYTE bByteSize,BYTE bStopBits,BYTE bParity,DWORD dwBaudRate,DWORD fBinary) 
{ 
	m_hCom = NULL; 
	m_bComId = bComId; 
 
	m_bByteSize=bByteSize; 
	m_bStopBits=bStopBits; 
	m_bParity=bParity; 
	m_dwBaudRate=dwBaudRate; 
	m_fBinary=fBinary; 
} 
BOOL CComStatus::OpenConnection() 
{ 
	DCB        dcb ; 
	char csCom[10]; 
    COMMTIMEOUTS  CommTimeOuts ; 
 
    if((m_bComId < 0) || (m_bComId > 4)) 
		return FALSE;//´ÓCOM1µ˝COM4 
	if(m_hCom)//if already open 
		return FALSE; 
	m_rdos.Offset = 0; 
	m_rdos.OffsetHigh = 0; 
	m_rdos.hEvent = CreateEvent(NULL,TRUE,FALSE,NULL); 
	if(m_rdos.hEvent == NULL) 
		return FALSE; 
	m_wtos.Offset = 0; 
	m_wtos.OffsetHigh = 0; 
	m_wtos.hEvent = CreateEvent(NULL,TRUE,FALSE,NULL); 
	if(m_wtos.hEvent == NULL) 
	{ 
		CloseHandle(m_rdos.hEvent); 
		return FALSE; 
	} 
	wsprintf(csCom,"COM%d",m_bComId); 
	m_hCom = CreateFile(csCom,GENERIC_READ | GENERIC_WRITE, 
    0, 
    NULL, 
    OPEN_EXISTING, 
    FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, 
    NULL 
	); 
 
	if(m_hCom == INVALID_HANDLE_VALUE) { 
		return FALSE; 
	} 
	else 
	{ 
      SetCommMask( m_hCom, EV_RXCHAR ) ; 
      SetupComm( m_hCom, 5120,5120 ) ; 
      PurgeComm( m_hCom, PURGE_TXABORT | PURGE_RXABORT | 
                                      PURGE_TXCLEAR | PURGE_RXCLEAR ) ; 
 
      CommTimeOuts.ReadIntervalTimeout = MAXDWORD ; 
      CommTimeOuts.ReadTotalTimeoutMultiplier = MAXDWORD;//((dwTemp > 0) ? dwTemp : 1); 
      CommTimeOuts.ReadTotalTimeoutConstant = 1000 ; 
       
	  CommTimeOuts.WriteTotalTimeoutMultiplier = MAXDWORD;//( npTTYInfo ) ; 
      CommTimeOuts.WriteTotalTimeoutConstant = 1000; 
      SetCommTimeouts( m_hCom, &CommTimeOuts ) ; 
	} 
	if(!SetupConnection()) 
	{ 
		CloseConnection(); 
		return FALSE; 
	} 
	EscapeCommFunction( m_hCom, SETDTR ); 
	GetCommState(m_hCom,&dcb); 
 
	return TRUE; 
} 
BOOL CComStatus::CloseConnection() 
{ 
   DCB        dcb ; 
   if (NULL == m_hCom) 
      return TRUE; 
 
   SetCommMask( m_hCom, 0 ) ; 
 
   EscapeCommFunction( m_hCom, CLRDTR ) ; 
   PurgeComm( m_hCom, PURGE_TXABORT | PURGE_RXABORT | 
                                   PURGE_TXCLEAR | PURGE_RXCLEAR ) ; 
   GetCommState(m_hCom,&dcb); 
 
   CloseHandle( m_hCom ) ; 
   m_hCom = NULL; 
   CloseHandle(m_rdos.hEvent); 
   CloseHandle(m_wtos.hEvent); 
 
   return TRUE ; 
} 
BOOL CComStatus::SetupConnection() 
{ 
   BOOL       fRetVal ; 
   DCB        dcb ; 
	if(m_hCom == NULL) 
		return FALSE;  
   dcb.DCBlength = sizeof( DCB ) ; 
 
   GetCommState( m_hCom, &dcb ) ; 
 
   dcb.BaudRate = m_dwBaudRate; 
   dcb.ByteSize = m_bByteSize; 
   dcb.Parity =  m_bParity; 
   dcb.StopBits = m_bStopBits ; 
 
   fRetVal = SetCommState( m_hCom, &dcb ) ; 
 
   return ( fRetVal ) ; 
 
} // end of SetupConnection() 
int ReadCommBlock(CComStatus& comDev,LPSTR lpszBlock, int nMaxLength ) 
{ 
   BOOL       fReadStat ; 
 
   COMSTAT    ComStat ; 
   DWORD      dwErrorFlags; 
   DWORD      dwLength; 
   DWORD      dwError; 
   char       szError[ 128 ] ; 
 
   memset (szError,0,128); 
   ClearCommError( comDev.m_hCom, &dwErrorFlags, &ComStat ) ; 
   dwLength = min( (DWORD) nMaxLength, ComStat.cbInQue ) ; 
    
   if (dwLength > 0) 
   { 
      fReadStat = ReadFile( comDev.m_hCom, lpszBlock,dwLength, &dwLength, &(comDev.m_rdos) ) ; 
	  //fReadStat = ReadFile( comDev.m_hCom, lpszBlock,dwLength, &dwLength, NULL ) ; 
      if (!fReadStat) 
      { 
         if (GetLastError() == ERROR_IO_PENDING) 
         { 
            OutputDebugString("\n\rIO Pending"); 
            while(!GetOverlappedResult( comDev.m_hCom , 
               &(comDev.m_rdos), &dwLength, TRUE )) 
            { 
               dwError = GetLastError(); 
               if(dwError == ERROR_IO_INCOMPLETE) 
                  continue; 
               else 
               { 
                  wsprintf( szError, "", dwError ) ; 
                  ClearCommError( comDev.m_hCom , &dwErrorFlags, &ComStat ) ; 
                  break; 
               } 
 
            } 
 
	      } 
         else 
         { 
            dwLength = 0 ; 
            ClearCommError( comDev.m_hCom , &dwErrorFlags, &ComStat ) ; 
         } 
      } 
   } 
 
   return dwLength; 
 
} // end of ReadCommBlock() 
BOOL WriteCommBlock( CComStatus& comDev, LPSTR lpByte , DWORD dwBytesToWrite) 
{ 
 
   BOOL        fWriteStat ; 
   DWORD       dwBytesWritten ; 
   DWORD       dwErrorFlags; 
   DWORD   	   dwError; 
   DWORD       dwBytesSent=0; 
   COMSTAT     ComStat; 
   char        szError[ 128 ] ; 
 
   fWriteStat = WriteFile( comDev.m_hCom , lpByte, dwBytesToWrite,&dwBytesWritten, &( comDev.m_wtos) ) ; 
   if (!fWriteStat) 
   { 
      if(GetLastError() == ERROR_IO_PENDING) 
      { 
         while(!GetOverlappedResult( comDev.m_hCom, 
            &(comDev.m_wtos), &dwBytesWritten, TRUE )) 
         { 
            dwError = GetLastError(); 
            if(dwError == ERROR_IO_INCOMPLETE) 
            { 
               dwBytesSent += dwBytesWritten; 
               continue; 
            } 
            else 
            { 
               wsprintf( szError, "", dwError ) ; 
               ClearCommError( comDev.m_hCom, &dwErrorFlags, &ComStat ) ; 
               break; 
            } 
         } 
 
         dwBytesSent += dwBytesWritten; 
 
         if( dwBytesSent != dwBytesToWrite ) 
             wsprintf(szError,"\nProbable Write Timeout: Total of %ld bytes sent", dwBytesSent); 
         else 
             wsprintf(szError,"\n%ld bytes written,byte=%s", dwBytesSent,lpByte); 
 
         OutputDebugString(szError); 
 
      } 
      else 
      { 
         ClearCommError( comDev.m_hCom, &dwErrorFlags, &ComStat ) ; 
		 //cout<<"WriteFile=:"<