readthread.cpp

GSM modem通讯控件

// ReadThread.cpp : implementation file
//

#include "stdafx.h"
#include "commCtrl.h"
#include "ReadThread.h"
#include "mycomm.h"
#include "waveCommCtl.h"

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

/////////////////////////////////////////////////////////////////////////////
// CReadThread

IMPLEMENT_DYNCREATE(CReadThread, CWinThread)
CReadThread::CReadThread()
{
}
CReadThread::~CReadThread()
{
}

BOOL CReadThread::InitInstance()
{

    BYTE szInputBuffer[1000];
    DWORD nNumberOfBytesRead;

    HANDLE HandlesToWaitFor[3];
    DWORD dwHandleSignaled;

    DWORD fdwEvtMask;
	MSG msg;

  
    OVERLAPPED overlappedRead  = {0, 0, 0, 0, NULL};
    OVERLAPPED overlappedCommEvent = {0, 0, 0, 0, NULL};
    overlappedRead.hEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
    overlappedCommEvent.hEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
 
    HandlesToWaitFor[0] = overlappedCommEvent.hEvent;
    HandlesToWaitFor[1] = overlappedRead.hEvent;


    if (!SetCommMask(pComm->hCommFile,EV_ERR)) goto EndReadThread;
    if (!SetupCommEvent(&overlappedCommEvent, &fdwEvtMask))  goto EndReadThread;
    if (!SetupReadEvent(&overlappedRead,szInputBuffer, 1000,&nNumberOfBytesRead))  goto EndReadThread;
   
    while (TRUE)
    {
        // Wait until some event occurs (data to read; error; stopping).
        dwHandleSignaled = 
            MsgWaitForMultipleObjects(2, HandlesToWaitFor,
                FALSE, INFINITE,QS_ALLPOSTMESSAGE);

        // Which event occured?
        switch(dwHandleSignaled)
        {
            case WAIT_OBJECT_0:     // Signal to end the thread.
            {
                // Handle the CommEvent.
                if (!HandleCommEvent(&overlappedCommEvent, &fdwEvtMask, TRUE))
                {
                    goto EndReadThread;
                }

                // Start waiting for the next CommEvent.
                if (!SetupCommEvent(&overlappedCommEvent, &fdwEvtMask))
                {
                    goto EndReadThread;
                }
                break;
            }

            case WAIT_OBJECT_0 + 1: // CommEvent signaled.
            {
                // Get the new data!
                if (!HandleReadEvent(&overlappedRead,
                            szInputBuffer, 1000,
                            &nNumberOfBytesRead))
                {
                    
                    goto EndReadThread;
                }

                // Wait for more new data.
                if (!SetupReadEvent(&overlappedRead,
                            szInputBuffer, 1000,
                            &nNumberOfBytesRead))
                {
                    goto EndReadThread;
                }
                break;
            }
             case WAIT_OBJECT_0 + 2:
			{
				
				PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
                if (msg.hwnd != NULL)
				{
                 TranslateMessage(&msg);
                 DispatchMessage(&msg);
                 break;
				}
              if (msg.message==PWM_QUIT)
				{
				goto EndReadThread;
		    	}
            }

        } // End of switch(dwHandleSignaled).

    } // End of while(TRUE) loop.


EndReadThread:

    PurgeComm(pComm->hCommFile, PURGE_RXABORT | PURGE_RXCLEAR);
    CloseHandle(overlappedRead.hEvent);
    CloseHandle(overlappedCommEvent.hEvent);
  	return false;
}

int CReadThread::ExitInstance()
{
	// TODO:  perform any per-thread cleanup here
	PurgeComm(pComm->hCommFile, PURGE_TXABORT | PURGE_TXCLEAR);
	return CWinThread::ExitInstance();
}

BEGIN_MESSAGE_MAP(CReadThread, CWinThread)
	//{{AFX_MSG_MAP(CReadThread)
		// NOTE - the ClassWizard will add and remove mapping macros here.
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CReadThread message handlers

BOOL CReadThread::SetupCommEvent(LPOVERLAPPED lpOverlappedCommEvent, LPDWORD lpfdwEvtMask)
{
  DWORD dwLastError;
   StartSetupCommEvent:

     // Start waiting for Comm Errors.
    if (WaitCommEvent(pComm->hCommFile, lpfdwEvtMask, lpOverlappedCommEvent))
    {
        // This could happen if there was an error waiting on the
        // comm port.  Lets try and handle it.

        if (!HandleCommEvent(NULL, lpfdwEvtMask, FALSE))
            return FALSE;

        // What could cause infinite recursion at this point?
        goto StartSetupCommEvent;
    }
    dwLastError = GetLastError();
    if (dwLastError == ERROR_IO_PENDING)
    {
        return TRUE;//设置成功
    }
   return FALSE;
}

BOOL CReadThread::HandleCommEvent(LPOVERLAPPED lpOverlappedCommEvent, LPDWORD lpfdwEvtMask, BOOL fRetrieveEvent)
{
    DWORD dwDummy;
    DWORD dwErrors;
 	CString errorStr;

  if (fRetrieveEvent)
        if (!GetOverlappedResult(pComm->hCommFile, 
                lpOverlappedCommEvent, &dwDummy, FALSE))
                    return FALSE;
  if (*lpfdwEvtMask & EV_ERR)
    {
       if (!ClearCommError(pComm->hCommFile, &dwErrors, NULL)) return FALSE;
       errorStr="错误：";
       if (dwErrors == 0)  errorStr=errorStr+"NULL Error;";
       if (dwErrors & CE_FRAME) errorStr=errorStr+"CE_FRAME";
       if (dwErrors & CE_OVERRUN) errorStr=errorStr+"CE_OVERRUN";
       if (dwErrors & CE_RXPARITY) errorStr=errorStr+"CE_RXPARITY";
       if (dwErrors & ~ (CE_FRAME | CE_OVERRUN | CE_RXPARITY)) errorStr=errorStr+"EV_ERR Unknown EvtMask";
       pComm->OnEvent(CString("发生错误：")+CString(errorStr));
        return TRUE;
    }

   return FALSE;
}

BOOL CReadThread::SetupReadEvent(LPOVERLAPPED lpOverlappedRead, BYTE *lpszInputBuffer, DWORD dwSizeofBuffer, LPDWORD lpnNumberOfBytesRead)
{
  DWORD dwLastError;

     while(ReadFile(pComm->hCommFile,lpszInputBuffer, dwSizeofBuffer,
            lpnNumberOfBytesRead, lpOverlappedRead))
    {
       if (!HandleReadData(lpszInputBuffer, *lpnNumberOfBytesRead))
        {
            return FALSE;
        }
    }

    dwLastError = GetLastError();
    if (dwLastError == ERROR_IO_PENDING)    return TRUE;
    return FALSE;
}

BOOL CReadThread::HandleReadData(BYTE *lpszInputBuffer, DWORD dwSizeofBuffer)
{
 
   if (dwSizeofBuffer)
    {
        BYTE* lpszPostedBytes;
        lpszPostedBytes =(BYTE*) LocalAlloc(LPTR,dwSizeofBuffer+1);
        memcpy(lpszPostedBytes, lpszInputBuffer, dwSizeofBuffer);
        lpszPostedBytes[dwSizeofBuffer] = '\0';
        pComm->m_CtrlWin->ProcessCommData(lpszPostedBytes, dwSizeofBuffer);
   } 
	return TRUE;
}

BOOL CReadThread::HandleReadEvent(LPOVERLAPPED lpOverlappedRead, BYTE *lpszInputBuffer, DWORD dwSizeofBuffer, LPDWORD lpnNumberOfBytesRead)
{

    if (GetOverlappedResult(pComm->hCommFile,
            lpOverlappedRead, lpnNumberOfBytesRead, FALSE))
    {
	    pComm->m_CtrlWin->ProcessCommData(lpszInputBuffer, *lpnNumberOfBytesRead);
		return TRUE;
    }

    return FALSE;
}