mycomm.cpp

GSM modem通讯控件

// MyComm.cpp : implementation file
//

#include "stdafx.h"
#include "commctrl.h"
#include "MyComm.h"
#include "readthread.h"
#include "writethread.h"
#include "WaveCommCtl.h"

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

/////////////////////////////////////////////////////////////////////////////
// CMyComm

CMyComm::CMyComm()
{
}

CMyComm::~CMyComm()
{
	CloseHandle(hCommFile);
}


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


/////////////////////////////////////////////////////////////////////////////
// CMyComm message handlers

BOOL CMyComm::InitComm(int port)
{
	CString portstr;
	portstr.Format("COM%d",port);
	DCB dcb;
	hCommFile=CreateFile(portstr,GENERIC_READ|GENERIC_WRITE,0,
		NULL,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,NULL);
	if (hCommFile == (HANDLE)-1)
	{
		m_CtrlWin->CommResult(0);
		return FALSE;
	}

	GetCommState(hCommFile, &dcb);
    
	dcb.BaudRate=9600;
	dcb.StopBits=ONESTOPBIT;
	dcb.Parity=NOPARITY;
	dcb.ByteSize=8;
	dcb.fAbortOnError = FALSE;
    SetCommState(hCommFile,&dcb);

	COMMTIMEOUTS timeouts;
    GetCommTimeouts(hCommFile, &timeouts);
	timeouts.ReadIntervalTimeout=100;
	timeouts.ReadTotalTimeoutConstant=0;
	timeouts.ReadTotalTimeoutMultiplier=0;
	timeouts.WriteTotalTimeoutConstant=0;
	timeouts.WriteTotalTimeoutMultiplier=0;
	SetCommTimeouts(hCommFile,&timeouts);

	
	OVERLAPPED overlapped_read = {0, 0, 0, 0, NULL};

	overlapped_read.hEvent=CreateEvent(NULL,TRUE,TRUE,NULL);
	OVERLAPPED overlapped_write={0,0,0,0,NULL};
	overlapped_write.hEvent=CreateEvent(NULL,TRUE,TRUE,NULL);
	OVERLAPPED overlapped_commevent={0,0,0,0,NULL};
	overlapped_commevent.hEvent=CreateEvent(NULL,TRUE,TRUE,NULL);

	PurgeComm(hCommFile, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
	return  TRUE;

}
void CMyComm::Start()
{
	pReadThread=AfxBeginThread(RUNTIME_CLASS(CReadThread),THREAD_PRIORITY_HIGHEST,0,
	CREATE_SUSPENDED,NULL);
	((CReadThread *)pReadThread)->pComm=this;
	ID_ReadThread=((CReadThread *)pReadThread)->m_nThreadID;
	hReadThread=((CReadThread *)pReadThread)->m_hThread;
	pReadThread->ResumeThread();

	pWriteThread=AfxBeginThread(RUNTIME_CLASS(CWriteThread),THREAD_PRIORITY_HIGHEST,0,
		CREATE_SUSPENDED,NULL);
	((CWriteThread *)pWriteThread)->pComm=this;
	ID_WriteThread=((CWriteThread *)pWriteThread)->m_nThreadID;
	hWriteThread=((CWriteThread *)pWriteThread)->m_hThread;
	pWriteThread->ResumeThread();

} 

void CMyComm::Stop()
{

	PostThreadMessage(ID_WriteThread, PWM_QUIT,0,0); 
  	if (hWriteThread)
    {      
        PurgeComm(hCommFile, PURGE_TXABORT | PURGE_TXCLEAR);
       if (WaitForSingleObject(hWriteThread, 10000) == WAIT_TIMEOUT)
        {
            TerminateThread(hWriteThread, 0);
            CloseHandle(hWriteThread);
            hWriteThread = 0;
            ID_WriteThread = 0;

        }
    }



	PostThreadMessage(ID_ReadThread, PWM_QUIT,0,0);
	if (hReadThread)
    {      
        PurgeComm(hCommFile, PURGE_RXABORT | PURGE_RXCLEAR);
       if (WaitForSingleObject(hReadThread, 10000) == WAIT_TIMEOUT)
        {
            TerminateThread(hReadThread, 0);
            CloseHandle(hReadThread);
            hReadThread = 0;
            ID_ReadThread = 0;
        }
    }

	CloseHandle(hCommFile);

}

BOOL CMyComm::WriteCommString(BYTE *lpszStringToWrite, DWORD dwSizeofStringToWrite)
{

//	m_CtrlWin->OnGetData("Send Once");

	hWriteThread=((CWriteThread *)pWriteThread)->m_hThread;
	if (hWriteThread)
	 {
        if (PostThreadMessage(ID_WriteThread, PWM_COMMWRITE, 
                (WPARAM) dwSizeofStringToWrite, (LPARAM) lpszStringToWrite))
        {
            return TRUE;
        }
	 }
	LocalFree(lpszStringToWrite);
    return FALSE;
}

void CMyComm::OnEvent(CString str)
{
 
}