serialcom.cpp

本程序的开发环境是VC++,实现的功能是串口通信.

// SerialCom.cpp: implementation of the CSerialCom class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "矩阵控制器.h"
#include "SerialCom.h"
#include "WatchThread.h"
#include "ComNotifyWnd.h"
//#include "矩阵控制器Dlg.h"

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

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

CSerialCom::CSerialCom()
{
	BOOL m_connected=FALSE;
    m_count=0;
	m_bOnline=FALSE;
	m_bContinue=FALSE;
	m_iState=STATE_WAIT;
}

CSerialCom::~CSerialCom()
{

}
BOOL CSerialCom::OpenCom()
{
// Open and set comm
	DCB dcb;
	m_hCom=CreateFile("Com1",
					  GENERIC_READ|GENERIC_WRITE,
					  0,
					  NULL,
					  OPEN_EXISTING,
					  FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,
					  NULL);
	if (m_hCom==(HANDLE)-1) return FALSE;
	if (!SetCommMask(m_hCom,EV_RXCHAR)) return FALSE;
	if (!SetupComm(m_hCom,8192,8192)) return FALSE;
    if (!PurgeComm(m_hCom, PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR )) return FALSE;
	if (!GetCommState(m_hCom,&dcb)) return FALSE;
	dcb.BaudRate =CBR_9600;
	dcb.ByteSize =8 ;
	dcb.Parity = NOPARITY;
	dcb.StopBits = 0;
	dcb.fBinary = TRUE;
	dcb.fOutxCtsFlow=FALSE;
	dcb.fOutxDsrFlow=FALSE;
	dcb.fDtrControl=DTR_CONTROL_DISABLE;
	dcb.fDsrSensitivity=FALSE;
	dcb.fTXContinueOnXoff=TRUE;
	dcb.fOutX =FALSE;
	dcb.fInX=FALSE;
	dcb.fRtsControl=RTS_CONTROL_DISABLE;
	dcb.fAbortOnError=FALSE;
	if (!SetCommState(m_hCom,&dcb)) return FALSE;

// Build a notify Windows
	CComNotifyWnd *pWnd=new CComNotifyWnd(this);
	pWnd->m_hWnd=NULL;
	    if (!pWnd->CreateEx(0, AfxRegisterWndClass(0),
			_T("Comm Notification Sink"),
            WS_OVERLAPPED, 0, 0, 0, 0, NULL, NULL))
    {
        TRACE0("Warning: unable to create socket notify");
        AfxThrowResourceException();
    }

	ASSERT(pWnd->m_hWnd != NULL);
	ASSERT(CWnd::FromHandlePermanent(pWnd->m_hWnd) == pWnd);
	m_pWnd=pWnd;

// Create overlapped
	m_osRead.Offset = 0;
	m_osRead.OffsetHigh = 0;
	m_osWrite.Offset = 0;
	m_osWrite.OffsetHigh = 0;

    m_osRead.hEvent = CreateEvent( NULL,
		                           TRUE,
								   FALSE,
								   NULL);
	if(m_osRead.hEvent==NULL) return FALSE;

    m_osWrite.hEvent = CreateEvent( NULL,    // no security
                                  TRUE,    // explicit reset req
                                  FALSE,   // initial event reset
                                  NULL ) ; // no name
	if (m_osWrite.hEvent==NULL) return FALSE;

// create event used to post message
	m_hPostEvent=CreateEvent(NULL,TRUE,TRUE,NULL);
	if (m_hPostEvent==NULL) return FALSE;

	m_bconnected=TRUE;
// Create Watchthread
	CWatchThread *thread;
	thread=new CWatchThread;
	thread->m_pCom=this;
	thread->CreateThread();
	return TRUE;
}

void CSerialCom::OnReceive()
{
	CMyDlg *m_pDlg=(CMyDlg *)AfxGetMainWnd();
	char c[8192];
	int len=ReadCommBlock(c,4096);
	int d;
	for(int i=0; i<len; i++)
	 {
		if (c[i] < 0)d=c[i]+256;
		else	d=c[i];
		m_pDlg->DisplayString(d);
	 }
 		
	SetEvent(m_hPostEvent);
}

int CSerialCom::ReadCommBlock(LPSTR lpszBlock, int nMaxLength)
{
   BOOL       fReadStat ;
   COMSTAT    ComStat ;
   DWORD      dwErrorFlags;
   DWORD      dwLength;
   DWORD      dwError;

   // only try to read number of bytes in queue
   ClearCommError( m_hCom, &dwErrorFlags, &ComStat ) ;
   dwLength = min( (DWORD) nMaxLength, ComStat.cbInQue ) ;
    
   if (dwLength > 0)
   {
      fReadStat = ReadFile( m_hCom, lpszBlock,
		                    dwLength, &dwLength, &m_osRead ) ;
      if (!fReadStat)
      {
         if (GetLastError() == ERROR_IO_PENDING)
         {
            while(!GetOverlappedResult( m_hCom,
               &m_osRead, &dwLength, TRUE ))
            {
               dwError = GetLastError();
               if(dwError == ERROR_IO_INCOMPLETE)
                  // normal result if not finished
                  continue;
               else
               {
                  // an error occurred, try to recover
                  ClearCommError( m_hCom, &dwErrorFlags, &ComStat ) ;
                  break;
               }

            }

	      }
         else
         {
            // some other error occurred
            dwLength = 0 ;
            ClearCommError( m_hCom, &dwErrorFlags, &ComStat ) ;
         }
      }
   }

   return ( dwLength ) ;
}

BOOL CSerialCom::WriteCommBlock(LPSTR lpByte, DWORD dwBytesToWrite)
{
   BOOL        fWriteStat ;
   DWORD       dwBytesWritten ;
   DWORD       dwErrorFlags;
   DWORD   	   dwError;
   DWORD       dwBytesSent=0;
   COMSTAT     ComStat;

   fWriteStat = WriteFile( m_hCom, lpByte, dwBytesToWrite,
                           &dwBytesWritten, &m_osWrite ) ;

   if (!fWriteStat)
   {
      if(GetLastError() == ERROR_IO_PENDING)
      {
         while(!GetOverlappedResult( m_hCom,
            &m_osWrite, &dwBytesWritten, TRUE ))
         {
            dwError = GetLastError();
            if(dwError == ERROR_IO_INCOMPLETE)
            {
               dwBytesSent += dwBytesWritten;
               continue;
            }
            else
            {
               ClearCommError( m_hCom, &dwErrorFlags, &ComStat ) ;
               break;
            }
         }
         dwBytesSent += dwBytesWritten;
      }
      else
      {
         ClearCommError( m_hCom, &dwErrorFlags, &ComStat ) ;
         return ( FALSE );
      }
   }
   return ( TRUE ) ;
}

void CSerialCom::OnAnalyse(char c)
{
}