writethread.cpp

GSM modem通讯控件

// WriteThread.cpp : implementation file
//

#include "stdafx.h"
#include "commCtrl.h"
#include "WriteThread.h"
#include "mycomm.h"

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

/////////////////////////////////////////////////////////////////////////////
// CWriteThread

IMPLEMENT_DYNCREATE(CWriteThread, CWinThread)

CWriteThread::CWriteThread()
{
}

CWriteThread::~CWriteThread()
{
}

BOOL CWriteThread::InitInstance()
{
	 MSG msg;
    DWORD dwHandleSignaled;

    // Needed for overlapped I/O.
    OVERLAPPED overlappedWrite = {0, 0, 0, 0, NULL};

    overlappedWrite.hEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
   while (TRUE)
    {
        if (!PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            dwHandleSignaled = 
                MsgWaitForMultipleObjects(0,NULL, FALSE,
                    INFINITE, QS_ALLINPUT);

            if (dwHandleSignaled==WAIT_OBJECT_0)    continue;
        }

        if (msg.hwnd != NULL)
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);

            continue;
        }
        switch(msg.message)
        {
            case PWM_COMMWRITE:  // New string to write to Comm port.
            {
 
                if (!WriteData(&overlappedWrite,
                        (BYTE*) msg.lParam, (DWORD) msg.wParam))
                {
             //       LocalFree((HLOCAL) msg.lParam); 
                    goto EndWriteThread;
                }
				 // Data was sent in a LocalAlloc()d buffer.  Must free it.
           //     LocalFree((HLOCAL) msg.lParam); 
				
                break;
            }
            case PWM_QUIT:
			{
				goto EndWriteThread;
		    		
			}
            default:
            {
              break;
            }
        } // End of switch(message)

    } // End of main loop.

    // Thats the end.  Now clean up.
  EndWriteThread:

    PurgeComm(pComm->hCommFile , PURGE_TXABORT | PURGE_TXCLEAR);

    CloseHandle(overlappedWrite.hEvent);
 	return false;
} 

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

BEGIN_MESSAGE_MAP(CWriteThread, CWinThread)
	//{{AFX_MSG_MAP(CWriteThread)
  //  ON_MESSAGE(PWM_COMMWRITE,OnWrite)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CWriteThread message handlers

BOOL CWriteThread::WriteData(LPOVERLAPPED lpOverlappedWrite, BYTE *lpszStringToWrite, DWORD dwNumberOfBytesToWrite)
{
    DWORD dwLastError;

    DWORD dwNumberOfBytesWritten = 0;
    DWORD dwWhereToStartWriting = 0; 
 
    do
    {
        if (!WriteFile(pComm->hCommFile,&lpszStringToWrite[ dwWhereToStartWriting ], 
                dwNumberOfBytesToWrite, &dwNumberOfBytesWritten,lpOverlappedWrite))
		{
			 dwLastError = GetLastError();
			if (dwLastError != ERROR_IO_PENDING)
			 {
                return FALSE;
			 }
            if (WAIT_OBJECT_0 == WaitForSingleObject(lpOverlappedWrite -> hEvent,INFINITE))
			 {
				pComm->OnEvent("TX_COMPLETE");
			 }
            if (!GetOverlappedResult(pComm->hCommFile,lpOverlappedWrite,&dwNumberOfBytesWritten, TRUE))
            {
                return FALSE;
            }
        }
        dwNumberOfBytesToWrite -= dwNumberOfBytesWritten;
        dwWhereToStartWriting += dwNumberOfBytesWritten;
    }while(dwNumberOfBytesToWrite > 0);  

    return TRUE;
}



void CWriteThread::OnWrite(WPARAM wparam,LPARAM lparam)
{

    OVERLAPPED overlappedWrite = {0, 0, 0, 0, NULL};
    overlappedWrite.hEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
    WriteData(&overlappedWrite,(BYTE*) lparam, (DWORD) wparam);
    LocalFree((HLOCAL) lparam);
	CloseHandle(overlappedWrite.hEvent);
}