communicatbass.cpp

我写的一个串口通讯的程序,该程序可以将收到的命令和文本重的程序进行比较,再将数据发回,适合通讯设备和电脑的通讯

// CommunicatBass.cpp : implementation file
//

#include "stdafx.h"
#include "CommunicatBass.h"

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

/////////////////////////////////////////////////////////////////////////////
// CCommunicatBass

CCommunicatBass::CCommunicatBass()
{
}

CCommunicatBass::~CCommunicatBass()
{
}
int CCommunicatBass::CreateCommInfo(NPCOMINFO pInfo)
{
   pInfo->m_hComDev =0;
   pInfo->m_bPort =1;
   pInfo->m_dwBaudRate =CBR_115200;
   pInfo->m_bByteSize=8;      
   pInfo->m_bParity=ODDPARITY;
   pInfo->m_bStopBits =ONESTOPBIT;   
   return (1) ;
} 

bool  CCommunicatBass::OpenConnection(NPCOMINFO pInfo)
{
   CString       szPort;
   bool       fRetVal ;        
   COMMTIMEOUTS  CommTimeOuts ;
   CWaitCursor WaitCursor;  
   szPort.Format("%s%d","com",pInfo->m_bPort);
   pInfo->m_hComDev =
      CreateFile( szPort, GENERIC_READ | GENERIC_WRITE,
                  0,                   
                  NULL,                
                  OPEN_EXISTING,
                  FILE_ATTRIBUTE_NORMAL |
                  FILE_FLAG_OVERLAPPED, 
                  NULL );
   if(pInfo->m_hComDev== (HANDLE) -1 )
      return ( false ) ;   
   else
   {
      SetCommMask(pInfo->m_hComDev, EV_RXCHAR ) ;
      SetupComm(pInfo->m_hComDev, 4096, 4096 ) ;
      PurgeComm(pInfo->m_hComDev , PURGE_TXABORT | PURGE_RXABORT |
                                      PURGE_TXCLEAR | PURGE_RXCLEAR ) ;      
      CommTimeOuts.ReadIntervalTimeout = 0xFFFFFFFF ;
      CommTimeOuts.ReadTotalTimeoutMultiplier = 0 ;
      CommTimeOuts.ReadTotalTimeoutConstant = 1000 ;
      CommTimeOuts.WriteTotalTimeoutMultiplier = 2*9600/pInfo->m_dwBaudRate ;
      CommTimeOuts.WriteTotalTimeoutConstant = 0 ;
      SetCommTimeouts(pInfo->m_hComDev , &CommTimeOuts ) ;	   
   }
   fRetVal = SetupConnection(pInfo) ;      
   if (fRetVal)   
       EscapeCommFunction(pInfo->m_hComDev, SETDTR );
   else
   {    
      CloseHandle(pInfo->m_hComDev) ;
	  AfxMessageBox("Fail to Set DCB Structure!"); 
   }
   return ( fRetVal ) ;
}

bool  CCommunicatBass::SetupConnection(NPCOMINFO pInfo )
{
   bool       fRetVal ;
   DCB        dcb ;
   dcb.DCBlength = sizeof( DCB ) ;
   GetCommState(pInfo->m_hComDev, &dcb ) ;
   dcb.BaudRate = pInfo->m_dwBaudRate;
   dcb.ByteSize = pInfo->m_bByteSize;
   dcb.Parity = pInfo->m_bParity ;
   dcb.StopBits =pInfo->m_bStopBits ;
   fRetVal = SetCommState( pInfo->m_hComDev,&dcb ) ;
   return ( fRetVal ) ;
} 
bool  CCommunicatBass::CloseConnection(NPCOMINFO pInfo)
{
   SetCommMask( pInfo->m_hComDev, 0 ) ;
   EscapeCommFunction( pInfo->m_hComDev, CLRDTR ) ;
   PurgeComm( pInfo->m_hComDev, PURGE_TXABORT | PURGE_RXABORT |
                                    PURGE_TXCLEAR | PURGE_RXCLEAR ) ;
   CloseHandle( pInfo->m_hComDev ) ;
   return ( TRUE ) ;

} 
int  CCommunicatBass::ReadCommBlock(LPSTR lpszBlock, int nMaxLength ,NPCOMINFO pInfo)
{
   BOOL       fReadStat ;
   COMSTAT    ComStat ;
   DWORD      dwErrorFlags;
   DWORD      dwError;
   DWORD      dwLength; 
   char       szError[ 10 ] ;
   ClearCommError( pInfo->m_hComDev, &dwErrorFlags, &ComStat ) ;
   dwLength = min( (DWORD) nMaxLength, ComStat.cbInQue ) ;
   if(dwLength<0) return dwLength;
   fReadStat = ReadFile( pInfo->m_hComDev, lpszBlock,
		                    dwLength, &dwLength,NULL) ;   
   if (!fReadStat)
      {
         if (GetLastError() == ERROR_IO_PENDING)
         {
            AfxMessageBox("IO Pending!");
            while(!GetOverlappedResult( pInfo->m_hComDev,NULL, &dwLength, TRUE ))
            {
               dwError = GetLastError();
               if(dwError == ERROR_IO_INCOMPLETE)
	                  continue;
	           else
               {
                  wsprintf( szError, "<CE-%u>", dwError ) ;
				  AfxMessageBox(szError);
                  ClearCommError( pInfo->m_hComDev, &dwErrorFlags, &ComStat ) ;
                  if (dwErrorFlags > 0)
                  {
	                  wsprintf( szError, "<CE-%u>", dwErrorFlags ) ;
					  AfxMessageBox(szError);
                  }
                  break;
               }
            }         
	      }
        else
         {
            dwLength = 0 ;
            ClearCommError( pInfo->m_hComDev, &dwErrorFlags, &ComStat ) ;
            if (dwErrorFlags > 0)
            {
	            wsprintf( szError, "<CE-%u>", dwErrorFlags ) ;
	            AfxMessageBox(szError);
            }
		}
   }                 
  return ( dwLength ) ;
} 

bool  CCommunicatBass::WriteCommBlock( LPSTR lpByte , DWORD dwBytesToWrite,NPCOMINFO pInfo)
{

   bool        fWriteStat;
   DWORD       dwBytesWritten;
   DWORD       dwErrorFlags;
   DWORD   	   dwError;
   DWORD       dwBytesSent=0;
   COMSTAT     ComStat;
   char        szError[ 128 ] ;
  
   fWriteStat = WriteFile( pInfo->m_hComDev, lpByte, dwBytesToWrite,
                           &dwBytesWritten,NULL) ;   
   if (!fWriteStat)
   { 	  
      if(GetLastError() == ERROR_IO_PENDING)
      {
         while(!GetOverlappedResult( pInfo->m_hComDev,
            NULL, &dwBytesWritten, TRUE ))
         {
            dwError = GetLastError();
            if(dwError == ERROR_IO_INCOMPLETE)
            {               
               dwBytesSent += dwBytesWritten;
               continue;
            }
            else
            {              
               wsprintf( szError, "<CE-%u>", dwError ) ;
               AfxMessageBox(szError);
               ClearCommError( pInfo->m_hComDev, &dwErrorFlags, &ComStat ) ;
               if (dwErrorFlags > 0)
               {
                  wsprintf( szError, "<CE-%u>", dwErrorFlags ) ;
                  AfxMessageBox(szError);
               }
               break;
            }
         }
         dwBytesSent += dwBytesWritten;
         if( dwBytesSent != dwBytesToWrite )
             wsprintf(szError,"\nProbable Write Timeout: Total of %ld bytes sent", dwBytesSent);
         else
             wsprintf(szError,"\n%ld bytes written", dwBytesSent);
         AfxMessageBox(szError);
      }
    else
      {        
         ClearCommError( pInfo->m_hComDev, &dwErrorFlags, &ComStat ) ;
         if (dwErrorFlags > 0)
         {
            wsprintf( szError, "<CE-%u>", dwErrorFlags ) ;
            AfxMessageBox(szError);
         }
         return ( FALSE );
      }
   }   
   return ( TRUE ) ;
}