terminaldoc.cpp

VC6 多线程的串口操作

// TerminalDoc.cpp : implementation of the CTerminalDoc class
//

#include "stdafx.h"
#include "Terminal.h"

#include "TerminalDoc.h"
#include "SetupDlg.h"
#include "TerminalPassword.h"

#define INVALID_HANDLED_VALUE (HANDLE)(-1)
//#include "Winbase.h"

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

/////////////////////////////////////////////////////////////////////////////
// CTerminalDoc

IMPLEMENT_DYNCREATE(CTerminalDoc, CDocument)

BEGIN_MESSAGE_MAP(CTerminalDoc, CDocument)
	//{{AFX_MSG_MAP(CTerminalDoc)
	ON_COMMAND(ID_FILE_CONNECT, OnFileConnect)
	ON_COMMAND(ID_FILE_DISCONNECT, OnFileDisconnect)
	ON_COMMAND(ID_FILE_SETTINGS, OnFileSettings)
	ON_UPDATE_COMMAND_UI(ID_FILE_CONNECT, OnUpdateFileConnect)
	ON_UPDATE_COMMAND_UI(ID_FILE_DISCONNECT, OnUpdateFileDisconnect)
	ON_COMMAND(ID_FILE_SENDDOC, OnFileSenddoc)
	ON_UPDATE_COMMAND_UI(ID_FILE_SENDDOC, OnUpdateFileSenddoc)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CTerminalDoc construction/destruction

CTerminalDoc::CTerminalDoc()
{
	// TODO: add one-time construction code here
	m_bConnected=FALSE;
	m_pThread=NULL;
	m_bSendFlag=FALSE;
/*
	CFileFind fd;
	if(fd.FindFile(::GetCommDataFileName())){
		int m_nPort;
		CString m_strBaud,m_strDataBits;
		CFile cf;
		cf.Open(::GetCommDataFileName(),CFile::modeRead);
		CArchive ar(&cf,1,4096,NULL);
		ar>>m_nPort;
		ar>>m_strPort;
		ar>>m_nBaud;
		ar>>m_strBaud;
		m_nBaud=atoi(m_strBaud);
		ar>>m_nDataBits;
		ar>>m_strDataBits;
		m_nDataBits=atoi(m_strDataBits);
		ar>>m_nParity;
		ar>>m_nStopBits;
		ar>>m_nFlowCtrl;
		ar>>m_bEcho;
		ar>>m_bNewLine;
		ar.Close();
		cf.Close();
	}
	fd.Close();
*/
	int m_nPort;
	CString m_strBaud,m_strDataBits;
	m_strPort=AfxGetApp()->GetProfileString("Serial Port Set","m_strPort");
	m_strBaud=AfxGetApp()->GetProfileString("Serial Port Set","m_strBaud");
	m_nBaud=atoi(m_strBaud);
	m_strDataBits=AfxGetApp()->GetProfileString("Serial Port Set","m_strDataBits");
	m_nDataBits=atoi(m_strDataBits);
	m_nPort=AfxGetApp()->GetProfileInt("Serial Port Set","m_nPort",0);
	//m_nBaud=AfxGetApp()->GetProfileInt("Serial Port Set","m_nBaud",0);
	//m_nDataBits=AfxGetApp()->GetProfileInt("Serial Port Set","m_nDataBits",0);
	m_nParity=AfxGetApp()->GetProfileInt("Serial Port Set","m_nParity",0);
	m_nStopBits=AfxGetApp()->GetProfileInt("Serial Port Set","m_nStopBits",0);
	m_nFlowCtrl=AfxGetApp()->GetProfileInt("Serial Port Set","m_nFlowCtrl",0);
	m_bEcho=AfxGetApp()->GetProfileInt("Serial Port Set","m_bEcho",0);
	m_bNewLine=AfxGetApp()->GetProfileInt("Serial Port Set","m_bNewLine",0);
}

CTerminalDoc::~CTerminalDoc()
{
	if(m_bConnected)
		CloseConnection();
	if(m_hPostMsgEvent)
		CloseHandle(m_hPostMsgEvent);
	if(m_osRead.hEvent)
		CloseHandle(m_osRead.hEvent);
	if(m_osWrite.hEvent)
		CloseHandle(m_osWrite.hEvent);
}

BOOL CTerminalDoc::OnNewDocument()
{
	if (!CDocument::OnNewDocument())
		return FALSE;
	((CEditView*)m_viewList.GetHead())->SetWindowText(NULL);

	// TODO: add reinitialization code here
	// (SDI documents will reuse this document)
	if((m_hPostMsgEvent=CreateEvent(NULL,TRUE,TRUE,NULL))==NULL)
		return FALSE;
	memset(&m_osRead,0,sizeof(OVERLAPPED));
	memset(&m_osWrite,0,sizeof(OVERLAPPED));

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



/////////////////////////////////////////////////////////////////////////////
// CTerminalDoc serialization

void CTerminalDoc::Serialize(CArchive& ar)
{
	// CEditView contains an edit control which handles all serialization
	//ar..GetFile()->m_hFile
	
	if(m_bSendFlag){
		if(m_bEcho)
			((CEditView*)m_viewList.GetHead())->SerializeRaw(ar);
		char buf[2048];//CArchive::store
		int nCount;
		ar.GetFile()->SeekToBegin();
		while(nCount=ar.Read(buf,2048))
			if(WriteComm(buf,nCount)==0)
				break;
		m_bSendFlag=FALSE;
	}
	else
		((CEditView*)m_viewList.GetHead())->SerializeRaw(ar);
}

/////////////////////////////////////////////////////////////////////////////
// CTerminalDoc diagnostics

#ifdef _DEBUG
void CTerminalDoc::AssertValid() const
{
	CDocument::AssertValid();
}

void CTerminalDoc::Dump(CDumpContext& dc) const
{
	CDocument::Dump(dc);
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CTerminalDoc commands

void CTerminalDoc::OnFileConnect() 
{
	// TODO: Add your command handler code here
	if(!OpenConnetion())
		AfxMessageBox("Can't open Connection");

}

void CTerminalDoc::OnFileDisconnect() 
{
	// TODO: Add your command handler code here
	
	CloseConnection();
}

void CTerminalDoc::OnFileSettings() 
{
	// TODO: Add your command handler code here
	CSetupDlg dlg;
	//CString str;
	dlg.m_bConnected=m_bConnected;
	if(dlg.DoModal()==IDOK){

		m_strPort=dlg.m_strPort;
		m_nBaud=atoi(dlg.m_strBaud);
		m_nDataBits=atoi(dlg.m_strDataBits);
		m_nParity=dlg.m_nParity;
		m_nStopBits=dlg.m_nStopBits;
		m_nFlowCtrl=dlg.m_nFlowCtrl;
		m_bEcho=dlg.m_bEcho;
		m_bNewLine=dlg.m_bNewLine;
		if(m_bConnected)
			if(!ConfigConnection())
				AfxMessageBox("Can't realize the settings!");
	}
}

void CTerminalDoc::OnUpdateFileConnect(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	pCmdUI->Enable(!m_bConnected);
	//pCmdUI->SetCheck(m_bConnected);
}

void CTerminalDoc::OnUpdateFileDisconnect(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	pCmdUI->Enable(m_bConnected);
	//pCmdUI->SetCheck(!m_bConnected);
}

BOOL CTerminalDoc::OpenConnetion()
{
	COMMTIMEOUTS	TimeOuts;
	POSITION		firstViewPos;
	CView*			pView;
	firstViewPos=GetFirstViewPosition();
	pView=GetNextView(firstViewPos);
	m_hTermWnd=pView->GetSafeHwnd();
	if(m_bConnected)
		return FALSE;
	m_hCom=CreateFile(m_strPort,GENERIC_READ|GENERIC_WRITE,
		0,NULL,OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,NULL);
	if(m_hCom==INVALID_HANDLED_VALUE)//(HANDLE)-1)
		return FALSE;
	SetupComm(m_hCom,MAXBLOCK,MAXBLOCK);
	SetCommMask(m_hCom,EV_RXCHAR);
	
	TimeOuts.ReadIntervalTimeout=MAXDWORD;
	TimeOuts.ReadTotalTimeoutMultiplier=0;
	TimeOuts.ReadTotalTimeoutConstant=0;

	TimeOuts.WriteTotalTimeoutMultiplier=50;//50;
	TimeOuts.WriteTotalTimeoutConstant=20;//2000;//30;
	SetCommTimeouts(m_hCom,&TimeOuts);
	if(ConfigConnection()){
		m_pThread=AfxBeginThread(CommProc,this,THREAD_PRIORITY_NORMAL,
			0,CREATE_SUSPENDED,NULL);
		if(m_pThread==NULL){
			CloseHandle(m_hCom);
			return FALSE;
		}
		else{
			m_bConnected=TRUE;
			m_pThread->ResumeThread();
		}
	}
	else{
		CloseHandle(m_hCom);
		return FALSE;
	}
	return TRUE;
}

void CTerminalDoc::CloseConnection()
{
	if(!m_bConnected)
		return;
	m_bConnected=FALSE;
	SetEvent(m_hPostMsgEvent);
	SetCommMask(m_hCom,0);
	WaitForSingleObject(m_pThread->m_hThread,INFINITE);
	m_pThread=NULL;
	CloseHandle(m_hCom);
}
BOOL CTerminalDoc::CanCloseFrame(CFrameWnd* pFrame) 
{
	// TODO: Add your specialized code here and/or call the base class
	SetModifiedFlag(FALSE);
	return CDocument::CanCloseFrame(pFrame);
}

BOOL CTerminalDoc::ConfigConnection()
{

	DCB dcb;
	if(!GetCommState(m_hCom,&dcb))
		return FALSE;
	dcb.fBinary=TRUE;
	dcb.BaudRate=m_nBaud;
	dcb.ByteSize=(UCHAR)m_nDataBits;
	dcb.fParity=TRUE;
/*
	switch(m_nParity){
		case 0:
			dcb.Parity=NOPARITY;
			break;
		case 1:
			dcb.Parity=EVENPARITY;
			break;
		case 2:
			dcb.Parity=ODDPARITY;
			break;
		default:;
	}
	switch(m_nStopBits){
		case 0:
			dcb.StopBits=ONESTOPBIT;
			break;
		case 1:
			dcb.StopBits=ONE5STOPBITS;
			break;
		case 2:
			dcb.StopBits=TWOSTOPBITS;
			break;
		default:;
	}
*/
	dcb.Parity=m_nParity;
	dcb.StopBits=m_nStopBits;
	dcb.fOutxCtsFlow=m_nFlowCtrl==0;
	dcb.fRtsControl=m_nFlowCtrl==1?RTS_CONTROL_HANDSHAKE:RTS_CONTROL_ENABLE;
	dcb.fInX=dcb.fOutX=m_nFlowCtrl==2;
	dcb.XonChar=XON;
	dcb.XoffChar=XOFF;
	dcb.XonLim=50;
	dcb.XoffLim=50;
	return SetCommState(m_hCom,&dcb);
}
DWORD CTerminalDoc::ReadComm(char* buf,DWORD dwLength)
{
	DWORD length=100;
	COMSTAT ComStat;
	DWORD dwErrorFlags;
	//CString str;
	//str.Format("%d",GetLastError());
	//::AfxMessageBox(str);
	ClearCommError(m_hCom,&dwErrorFlags,&ComStat);
	//if(dwErrorFlags==CE_RXPARITY)
	length=min(dwLength,ComStat.cbInQue);
	ReadFile(m_hCom,buf,length,&length,&m_osRead);
	return length;
}

DWORD CTerminalDoc::WriteComm(char* buf,DWORD dwLength)
{
	BOOL fState;
	DWORD length=dwLength;
	COMSTAT ComStat;
	DWORD dwErrorFlags;
	ClearCommError(m_hCom,&dwErrorFlags,&ComStat);
	//if(dwErrorFlags==CE_RXPARITY)
	//	::AfxMessageBox("CE_RXPARITY");
	//length=min(dwLength,ComStat.cbOutQue);//ComStat.cbInQue);
	fState=WriteFile(m_hCom,buf,length,&length,&m_osWrite);
	if(!fState){
		if(GetLastError()==ERROR_IO_PENDING){
			length=dwLength;
			//WaitForSingleObject(m_osWrite.hEvent,10000);
			GetOverlappedResult(m_hCom,&m_osWrite,&length,TRUE);//FALSE
		}
		else
			length=0;
	}
	return length;
}
UINT CommProc(LPVOID pParam)
{
	OVERLAPPED os;
	DWORD dwMask,dwTrans;
	COMSTAT ComStat;
	DWORD dwErrorFlags;
	CTerminalDoc* pDoc=(CTerminalDoc*)pParam;
	memset(&os,0,sizeof(OVERLAPPED));
	os.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
	if(os.hEvent==NULL){
		AfxMessageBox("Can't create event object!");
		return (UINT)-1;
	}
	while(pDoc->m_bConnected){
		//CString str;
		//int i;
		//str.Format("%d",i=GetLastError());
		//if(i)::AfxMessageBox(str);
		ClearCommError(pDoc->m_hCom,&dwErrorFlags,&ComStat);
		if(ComStat.cbInQue){
			WaitForSingleObject(pDoc->m_hPostMsgEvent,INFINITE);
			ResetEvent(pDoc->m_hPostMsgEvent);
			::PostMessage(pDoc->m_hTermWnd,WM_COMMNOTIFY,EV_RXCHAR,0);
			continue;
		}
		//dwMask=0;
		if(!WaitCommEvent(pDoc->m_hCom,&dwMask,&os)){
			if(GetLastError()==ERROR_IO_PENDING)
				GetOverlappedResult(pDoc->m_hCom,&os,&dwTrans,TRUE);
			else{
				CloseHandle(os.hEvent);
				return (UINT)-1;
			}
		}
	}
	CloseHandle(os.hEvent);
	//AfxMessageBox("Exit CommProc");
	return 0;
}


void CTerminalDoc::OnFileSenddoc() 
{
	// TODO: Add your command handler code here
	m_bSendFlag=TRUE;
	::PostMessage(AfxGetApp()->m_pMainWnd->m_hWnd,WM_COMMAND,ID_FILE_OPEN,0);
}

void CTerminalDoc::OnUpdateFileSenddoc(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	pCmdUI->Enable(m_bConnected);
}