communication.cpp

RS232串口通讯,主要用来设置芯片中的数据.

#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, "<CE-%u>", 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, "<CE-%u>", 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=:"<<ComStat.cbInQue<<"WriteFile=:"<<ComStat.cbOutQue<<endl;
         return  FALSE ;
      }
   }
   return  TRUE  ;

} // end of WriteCommBlock()