common_serialdlg.cpp

同时可以打开两个串口的程序。可以进行收发试验。

			delete sComTemp;
			if(!((CSerialPort *)m_aPorts[i])->StartMonitoring())
				return;
			m_cSelBaud1.EnableWindow(FALSE);
			m_cSelCom1.EnableWindow(FALSE);
			m_cSelDatabit1.EnableWindow(FALSE);
			m_cSelStopbit1.EnableWindow(FALSE);
			m_cSelParity1.EnableWindow(FALSE);
			SetDlgItemText(IDC_BSTARTCOM1, "关闭串口");
			m_sComState1 = "打 开";
			if(m_chAutoSnd1.GetCheck())
			{
				m_chAutoSnd1.SetCheck(0);
			}
			m_chAutoSnd1.EnableWindow();
			m_eSendCycle1.EnableWindow();
			m_chTransmit1And2.SetCheck(0);
			if(m_bComNO2_Open)
				m_chTransmit1And2.EnableWindow();
			m_bClock1_Open = FALSE;
			m_bComNO1_Open = TRUE;
		}
		bStart = !bStart;
	}
	UpdateData(FALSE);
}

void CComMon_SERIALDlg::OnStartCom2() 
{
	UpdateData();
	int i = m_cSelCom2.GetCurSel();
	if(((CSerialPort*)m_aPorts[i])->GetComName() == m_sSelCom2)
	{
		static BOOL bStart = FALSE;
		if(bStart)
		{
			((CSerialPort *)m_aPorts[i])->NeedThreadStopping(FALSE);
			((CSerialPort *)m_aPorts[i])->ClosePort();
			m_cSelBaud2.EnableWindow();
			m_cSelCom2.EnableWindow();
			m_cSelDatabit2.EnableWindow();
			m_cSelStopbit2.EnableWindow();
			m_cSelParity2.EnableWindow();
			SetDlgItemText(IDC_BSTARTCOM2, "打开串口");
			m_sComState2 = "关 闭";
			if(m_chAutoSnd2.GetCheck())
				KillTimer(CLOCK1);
			m_chAutoSnd2.SetCheck(0);
			m_chAutoSnd2.EnableWindow(FALSE);
			m_eSendCycle2.EnableWindow(FALSE);
			m_chTransmit1And2.SetCheck(0);
			m_chTransmit1And2.EnableWindow(FALSE);
			m_bClock2_Open = FALSE;
			m_bComNO2_Open = FALSE;
		}
		else
		{
			CString sComName;
			int nPos = -1;
			m_cSelCom2.GetWindowText(sComName);
			sComName.MakeUpper();
			if((nPos = sComName.Find("COM")) == -1) return;
			char* sComNo;
			char* sComTemp = strdup(sComName);
			sComNo = sComTemp + lstrlen("COM");
			((CSerialPort *)m_aPorts[i])->NeedThreadStopping(TRUE);
			if(!((CSerialPort *)m_aPorts[i])->InitPort(this, atoi(sComNo), atoi(m_sSelBaud2),
				m_sSelParity2[0], atoi(m_sSelDatabit2), atoi(m_sSelStopbit2)))
			{
				delete sComTemp;
				return;
			}
			delete sComTemp;
			if(!((CSerialPort *)m_aPorts[i])->StartMonitoring())
				return;
			m_cSelBaud2.EnableWindow(FALSE);
			m_cSelCom2.EnableWindow(FALSE);
			m_cSelDatabit2.EnableWindow(FALSE);
			m_cSelStopbit2.EnableWindow(FALSE);
			m_cSelParity2.EnableWindow(FALSE);
			SetDlgItemText(IDC_BSTARTCOM2, "关闭串口");
			m_sComState2 = "打 开";
			if(m_chAutoSnd2.GetCheck())
			{
				m_chAutoSnd2.SetCheck(0);
			}
			m_chAutoSnd2.EnableWindow();
			m_eSendCycle2.EnableWindow();
			if(m_bComNO1_Open)
				m_chTransmit1And2.EnableWindow();
			m_bClock2_Open = FALSE;
			m_bComNO2_Open = TRUE;
		}
		bStart = !bStart;
	}
	UpdateData(FALSE);
}

void CComMon_SERIALDlg::OnSend1() 
{
	UpdateData();
	for(int i = 0; i < m_aPorts.GetSize(); i ++)
	{
		if(((CSerialPort*)m_aPorts[i])->GetComName() == m_sSelCom1)
		{
			if(m_bComNO1_Open ==  FALSE || m_sRESnd1.IsEmpty())
				break;
			m_sRESnd1.MakeUpper();
			if(m_chSendHex1.GetCheck())
			{
				char* sHex = new char[lstrlen(m_sRESnd1) + 1];
				if(lstrlen(m_sRESnd1) == 1)
					sprintf(sHex, "0%s", m_sRESnd1);
				else
					sprintf(sHex, "%s", m_sRESnd1);
				// must convert heximal first
				BYTE* pBuf = new BYTE[lstrlen(sHex) + 1];
				int iCount = CharToHex(pBuf, lstrlen(sHex), sHex, FALSE);
				m_nSendBytes1 += iCount;
				((CSerialPort*)m_aPorts[i])->WriteToPort(pBuf, iCount);

				delete []pBuf;
				delete []sHex;
			}
			else
			{
				m_nSendBytes1 += m_sRESnd1.GetLength();
				((CSerialPort*)m_aPorts[i])->WriteToPort((LPTSTR)(LPCTSTR)m_sRESnd1,
					m_sRESnd1.GetLength());
			}
			break;
		}
	}
	UpdateData(FALSE);
}

void CComMon_SERIALDlg::OnSend2() 
{
	UpdateData();
	for(int i = 0; i < m_aPorts.GetSize(); i ++)
	{
		if(((CSerialPort*)m_aPorts[i])->GetComName() == m_sSelCom2)
		{
			if(m_bComNO2_Open ==  FALSE || m_sRESnd2.IsEmpty())
				break;
			m_sRESnd2.MakeUpper();
			if(m_chSendHex2.GetCheck())
			{
				char* sHex = new char[lstrlen(m_sRESnd1) + 1];
				if(lstrlen(m_sRESnd1) == 1)
					sprintf(sHex, "0%s", m_sRESnd1);
				else
					sprintf(sHex, "%s", m_sRESnd1);
				// must convert heximal first
				BYTE* pBuf = new BYTE[lstrlen(sHex) + 1];
				int iCount = CharToHex(pBuf, lstrlen(sHex), sHex, FALSE);
				m_nSendBytes2 += iCount;
				((CSerialPort*)m_aPorts[i])->WriteToPort(pBuf, iCount);

				delete []pBuf;
			}
			else
			{
				m_nSendBytes2 += m_sRESnd2.GetLength();
				((CSerialPort*)m_aPorts[i])->WriteToPort((LPTSTR)(LPCTSTR)m_sRESnd2,
					m_sRESnd2.GetLength());
			}
			break;
		}
	}
	UpdateData(FALSE);
}

void CComMon_SERIALDlg::OnTransmit_1AND2() 
{
	if((m_aByteRcv1.GetSize() || m_aByteRcv2.GetSize()) &&
		AfxMessageBox("缓冲区中已经有数据，要清空当前的缓冲区吗？",
			MB_OKCANCEL | MB_ICONQUESTION) == IDOK)
	{
		m_sRERcv1.Empty();
		m_sRERcv2.Empty();
		m_sRESnd1.Empty();
		m_sRESnd2.Empty();
		m_aByteRcv1.RemoveAll();
		m_aByteRcv2.RemoveAll();
		UpdateData(FALSE);
	}
	UpdateData();
	CString sSnd1;
	// for 1
	switch(((CButton*)GetDlgItem(IDC_CTRANSMIT_1AND2))->GetCheck())
	{
	case 0:
		// no proc
		break;
	case 1:
		switch(((CButton*)GetDlgItem(IDC_CAUTORCVSND1))->GetCheck())
		{
		case 0:
			// no proc
			SetDlgItemText(IDC_RESEND1, m_sRERcv2);
			break;
		case 1:
			SetDlgItemText(IDC_RESEND1, m_sRERcv2);
			// send to 1
			OnSend1();
			break;
		default:
			ASSERT(FALSE);
		}
		break;
	default:
		ASSERT(FALSE);
	}

	// for 2
	switch(((CButton*)GetDlgItem(IDC_CTRANSMIT_1AND2))->GetCheck())
	{
	case 0:
		// no proc
		return;
	case 1:
		switch(((CButton*)GetDlgItem(IDC_CAUTORCVSND2))->GetCheck())
		{
		case 0:
			SetDlgItemText(IDC_RESEND2, m_sRERcv1);
			// no proc
			break;
		case 1:
			SetDlgItemText(IDC_RESEND2, m_sRERcv1);
			// send to 2
			OnSend2();
			break;
		default:
			ASSERT(FALSE);
		}
		break;
	default:
		ASSERT(FALSE);
	}
}

void CComMon_SERIALDlg::OnAutoRcvSnd1() 
{
	UpdateData();
	CString sSnd1;
	switch(((CButton*)GetDlgItem(IDC_CAUTORCVSND1))->GetCheck())
	{
	case 0:
		// stop send from 1
		m_bClock1_Open = FALSE;
		KillTimer(CLOCK1);
		return;
	case 1:
		sSnd1 = m_sRESnd1;
		SetTimer(CLOCK1, m_nSendCycle1, NULL);
		m_bClock1_Open = TRUE;
		switch(((CButton*)GetDlgItem(IDC_CTRANSMIT_1AND2))->GetCheck())
		{
		case 0:
			break;
		case 1:
			sSnd1 = m_sRERcv2;
			break;
		default:
			ASSERT(FALSE);
		}
		break;
	default:
		ASSERT(FALSE);
	}
}

void CComMon_SERIALDlg::OnAutoRcvSnd2() 
{
	UpdateData();
	CString sSnd1;
	switch(((CButton*)GetDlgItem(IDC_CAUTORCVSND2))->GetCheck())
	{
	case 0:
		// stop send from 2
		m_bClock2_Open = FALSE;
		KillTimer(CLOCK2);
		return;
	case 1:
		SetTimer(CLOCK2, m_nSendCycle2, NULL);
		m_bClock2_Open = TRUE;
		switch(((CButton*)GetDlgItem(IDC_CTRANSMIT_1AND2))->GetCheck())
		{
		case 0:
			sSnd1 = m_sRESnd1;
			break;
		case 1:
			sSnd1 = m_sRERcv2;
			break;
		default:
			ASSERT(FALSE);
		}
		break;
	default:
		ASSERT(FALSE);
	}
}

// config change
void CComMon_SERIALDlg::ConfigChange(int nSel)
{
	UpdateData();
	int nCom, n;
	CString sCom;
#if 1
	m_cSelCom1.GetLBText(nSel, sCom);
	for(n = 0; n < m_aPorts.GetSize(); n ++)
	{
		if(((CSerialPort*)m_aPorts[n])->GetComName() == sCom)
			break;
	}
	if(m_aPorts.GetSize() == n)
		ASSERT(FALSE);
#else
	switch(nSel)
	{
	case 0:
		sCom = m_sSelCom1;
		for(n = 0; n < m_aPorts.GetSize(); n ++)
		{
			if(((CSerialPort*)m_aPorts[n])->GetComName() == m_sSelCom1)
				break;
		}
		if(m_aPorts.GetSize() == n)
			ASSERT(FALSE);
		break;
	case 1:
		sCom = m_sSelCom2;
		for(n = 0; n < m_aPorts.GetSize(); n ++)
		{
			if(((CSerialPort*)m_aPorts[n])->GetComName() == m_sSelCom2)
				break;
		}
		if(m_aPorts.GetSize() == n)
			ASSERT(FALSE);
		break;
	default:
		ASSERT(FALSE);
	}

#endif
	CString sComRev = sCom;
	sComRev.TrimLeft("COM");
	nCom = atoi(sComRev);
	CString sBuffer;
	sBuffer.Format("%d", ((CSerialPort *)m_aPorts[n])->GetWriteBufferSize());
	
	DWORD dwCommEvents = ((CSerialPort *)m_aPorts[n])->GetCommEvents();
	BOOL CommBreakDetected = (dwCommEvents & EV_BREAK) > 0 ? TRUE : FALSE;
	BOOL CommCTSDetected   = (dwCommEvents & EV_CTS) > 0 ? TRUE : FALSE;
	BOOL CommDSRDetected   = (dwCommEvents & EV_DSR) > 0 ? TRUE : FALSE;
	BOOL CommERRDetected   = (dwCommEvents & EV_ERR) > 0 ? TRUE : FALSE;
	BOOL CommRingDetected  = (dwCommEvents & EV_RING) > 0 ? TRUE : FALSE;
	BOOL CommRLSDDetected  = (dwCommEvents & EV_RLSD) > 0 ? TRUE : FALSE;
	BOOL CommRxchar        = (dwCommEvents & EV_RXCHAR) > 0 ? TRUE : FALSE;
	BOOL CommRxcharFlag    = (dwCommEvents & EV_RXFLAG) > 0 ? TRUE : FALSE;
	BOOL CommTXEmpty       = (dwCommEvents & EV_TXEMPTY) > 0 ? TRUE : FALSE;

	dwCommEvents = 0;
	if (CommBreakDetected)
		dwCommEvents |= EV_BREAK;
	if (CommCTSDetected)
		dwCommEvents |= EV_CTS;
	if (CommDSRDetected)
		dwCommEvents |= EV_DSR;
	if (CommERRDetected)
		dwCommEvents |= EV_ERR;
	if (CommRingDetected)
		dwCommEvents |= EV_RING;
	if (CommRLSDDetected)
		dwCommEvents |= EV_RLSD;
	if (CommRxchar)
		dwCommEvents |= EV_RXCHAR;
	if (CommRxcharFlag)
		dwCommEvents |= EV_RXFLAG;
	if (CommTXEmpty)
		dwCommEvents |= EV_TXEMPTY;

#if 1
	if(sCom == m_sSelCom1)
	{
		((CSerialPort *)m_aPorts[n])->InitPort(this, nCom, 
			atoi(m_sSelBaud1),
			m_sSelParity1[0],
			atoi(m_sSelDatabit1),
			atoi(m_sSelStopbit1),
			dwCommEvents,
			atoi(sBuffer));
	}
	else if(sCom == m_sSelCom2)
	{
		((CSerialPort *)m_aPorts[n])->InitPort(this, nCom, 
			atoi(m_sSelBaud2),
			m_sSelParity2[0],
			atoi(m_sSelDatabit2),
			atoi(m_sSelStopbit2),
			dwCommEvents,
			atoi(sBuffer));
	}
	else
		ASSERT(FALSE);
#else
	switch(nSel)
	{
	case 0:
		((CSerialPort *)m_aPorts[n])->InitPort(this, nCom, 
			atoi(m_sSelBaud1),
			m_sSelParity1[0],
			atoi(m_sSelDatabit1),
			atoi(m_sSelStopbit1),
			dwCommEvents,
			atoi(sBuffer));
		break;
	case 1:
		((CSerialPort *)m_aPorts[n])->InitPort(this, nCom, 
			atoi(m_sSelBaud2),
			m_sSelParity2[0],
			atoi(m_sSelDatabit2),
			atoi(m_sSelStopbit2),
			dwCommEvents,
			atoi(sBuffer));
		break;
	default:
		ASSERT(FALSE);
	}
#endif

	((CSerialPort *)m_aPorts[n])->StartMonitoring();
	if(((CSerialPort *)m_aPorts[n])->IsNeedThreadStopping())
	{
		((CSerialPort *)m_aPorts[n])->StopMonitoring();
		((CSerialPort *)m_aPorts[n])->NeedThreadStopping(FALSE);
	}
}

void CComMon_SERIALDlg::LookupSerialState()
{
	for(int i = 0; i < m_aPorts.GetSize(); i ++)
	{
		CSerialPort* pSP = (CSerialPort*)m_aPorts.GetAt(i);
		if(!pSP->IsRunning())
			pSP->RestartMonitoring();
	}
}

void CComMon_SERIALDlg::ResumeSerial(int nSel)
{
	int nCom;
#if 1
	nCom = nSel;
#else
	switch(nSel)
	{
	case 0:
		nCom = m_cSelCom1.GetCurSel();
		break;
	case 1:
		nCom = m_cSelCom2.GetCurSel();
		break;
	default:
		ASSERT(FALSE);
	}
#endif
	CSerialPort* pSP = ((CSerialPort*)m_aPorts[nCom]);
	BOOL bRunning = pSP->IsRunning();
	pSP->NeedThreadStopping(!bRunning);
	if(!bRunning)
		pSP->RestartMonitoring();
}

void CComMon_SERIALDlg::OnEditchangeCom1() 
{
	BeginWaitCursor();
	CString sCom = m_sSelCom1;
	UpdateData();
	if(m_sSelCom1 == m_sSelCom2)
	{
		m_sSelCom1 = sCom;
		UpdateData(FALSE);
		MessageBox("正在使用该串口", "错误", MB_OK | MB_ICONSTOP);
		return;
	}
	for(int n = 0; n < m_cSelCom1.GetCount(); n ++)
	{
		CString s;
		m_cSelCom1.GetLBText(n, s);
		if(s == sCom)
		{
			((CSerialPort*)m_aPorts[n])->StopMonitoring();
			break;
		}
	}
	int i = m_cSelCom1.GetCurSel();
	ResumeSerial(i);
	Sleep(200);
	ConfigChange(i);
	EndWaitCursor();
}

void CComMon_SERIALDlg::OnEditchangeBaud1() 
{
	BeginWaitCursor();
	ResumeSerial(0);
	Sleep(200);
	ConfigChange(0);
	EndWaitCursor();
}

void CComMon_SERIALDlg::OnEditchangeDatabit1() 
{
	BeginWaitCursor();
	ResumeSerial(0);
	Sleep(200);
	ConfigChange(0);
	EndWaitCursor();
}

void CComMon_SERIALDlg::OnEditchangeCheckbit1() 
{
	BeginWaitCursor();
	ResumeSerial(0);
	Sleep(200);
	ConfigChange(0);
	EndWaitCursor();
}

void CComMon_SERIALDlg::OnEditchangeStopbit1() 
{
	BeginWaitCursor();
	ResumeSerial(0);
	Sleep(200);
	ConfigChange(0);
	EndWaitCursor();
}

void CComMon_SERIALDlg::OnSelchangeSelCheckbit1() 
{
	BeginWaitCursor();
	ResumeSerial(0);
	Sleep(200);
	ConfigChange(0);
	EndWaitCursor();
}

void CComMon_SERIALDlg::OnSelchangeSelBaud1() 
{
	BeginWaitCursor();
	ResumeSerial(0);
	Sleep(200);
	ConfigChange(0);
	EndWaitCursor();
}

void CComMon_SERIALDlg::OnSelchangeSelCom1() 
{
	BeginWaitCursor();
	CString sCom = m_sSelCom1;
	UpdateData();
	if(m_sSelCom1 == m_sSelCom2)
	{
		m_sSelCom1 = sCom;
		UpdateData(FALSE);
		MessageBox("正在使用该串口", "错误", MB_OK | MB_ICONSTOP);
		return;
	}
	for(int n = 0; n < m_cSelCom1.GetCount(); n ++)
	{
		CString s;
		m_cSelCom1.GetLBText(n, s);
		if(s == sCom)
		{
			((CSerialPort*)m_aPorts[n])->StopMonitoring();
			break;
		}
	}
	int i = m_cSelCom1.GetCurSel();
	ResumeSerial(i);
	Sleep(200);
	ConfigChange(i);
	EndWaitCursor();
}

void CComMon_SERIALDlg::OnSelchangeSelDatabit1() 
{
	BeginWaitCursor();
	ResumeSerial(0);
	Sleep(200);
	ConfigChange(0);
	EndWaitCursor();
}