testlfpprotocolview.cpp

一个很好的LFP规约调试器

// TestLFPProtocolView.cpp : implementation of the CTestLFPProtocolView class
//

#include "stdafx.h"
#include "TestLFPProtocol.h"

#include "TestLFPProtocolDoc.h"
#include "TestLFPProtocolView.h"

#include "ComSetting.h"
#include "PollSet.h"
#include "IniFile.h"
#include "LfpYk.h"

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

/////////////////////////////////////////////////////////////////////////////
// CTestLFPProtocolView
UINT masterlfpproto( LPVOID pParam )
{
	OVERLAPPED	os;
	DWORD		dwMask, dwTrans;
	COMSTAT		ComStat;
	DWORD		dwErrorFlags;

	CTestLFPProtocolView *pDoc = ( CTestLFPProtocolView* )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 ) {
		ClearCommError( pDoc->m_hCom, &dwErrorFlags, &ComStat );
		if( ComStat.cbInQue > 0 ) {
			// 无限等待WM_COMMNOTIFY消息被处理完
			WaitForSingleObject( pDoc->m_hPostMsgEvent, INFINITE );
			ResetEvent( pDoc->m_hPostMsgEvent );
			// 通知视图
			PostMessage( pDoc->GetSafeHwnd(), 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 );
	return 0L;
}

IMPLEMENT_DYNCREATE(CTestLFPProtocolView, CFormView)

BEGIN_MESSAGE_MAP(CTestLFPProtocolView, CFormView)
	//{{AFX_MSG_MAP(CTestLFPProtocolView)
	ON_COMMAND(ID_APP_COM_SETTING, OnAppComSetting)
	ON_COMMAND(ID_APP_COM_CONNECT, OnAppComConnect)
	ON_UPDATE_COMMAND_UI(ID_APP_COM_CONNECT, OnUpdateAppComConnect)
	ON_COMMAND(ID_APP_COM_DISCONNECT, OnAppComDisconnect)
	ON_UPDATE_COMMAND_UI(ID_APP_COM_DISCONNECT, OnUpdateAppComDisconnect)
	ON_WM_SIZE()
	ON_WM_TIMER()
	ON_COMMAND(IDM_SYSTEM_SETTING, OnSystemSetting)
	ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
	ON_UPDATE_COMMAND_UI(ID_FILE_OPEN, OnUpdateFileOpen)
	ON_COMMAND(ID_FILE_SAVE, OnFileSave)
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CFormView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CFormView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CFormView::OnFilePrintPreview)
	ON_MESSAGE(WM_COMMNOTIFY, MasterReceive)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CTestLFPProtocolView construction/destruction

CTestLFPProtocolView::CTestLFPProtocolView()
	: CFormView(CTestLFPProtocolView::IDD)
{
	//{{AFX_DATA_INIT(CTestLFPProtocolView)
	//}}AFX_DATA_INIT
	// TODO: add construction code here

	m_bConnected = FALSE;
	m_pThread = NULL;
	strcpy( strComNo, "COM1" );
	dwBaudRate = 9600;
	DataSize = 8;
	Parity = NOPARITY;
	StopBit = ONESTOPBIT;

	startaddr = 0;
	endaddr = 254;

	m_bInit = FALSE;
}

CTestLFPProtocolView::~CTestLFPProtocolView()
{
}

void CTestLFPProtocolView::DoDataExchange(CDataExchange* pDX)
{
	CFormView::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CTestLFPProtocolView)
	DDX_Control(pDX, IDC_RICHEDIT_MSG, m_MSG);
	//}}AFX_DATA_MAP
}

BOOL CTestLFPProtocolView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs
	return CFormView::PreCreateWindow(cs);
}

void CTestLFPProtocolView::ShowMSG( BYTE* buffer, int len, BOOL bIsSend )
{
	CString	str;
	CString	temp;
	if( !m_bshowmsg ) return;
	if( bIsSend ) {
		str += "<发送>";
	}
	else str += "<接收>";
	for( int i = 0; i < len; i++, buffer++ ) {
		temp.Format( "%02X", *buffer );
		str += temp;
	}
	str += "+\r\n";
	m_MSG.SetSelectionCharFormat( RichEditFormat );
	m_MSG.SetSel( -1, -1 );
	m_MSG.ReplaceSel( str );
 	if( m_MSG.GetLineCount() >= 400 ) {
 		m_MSG.SetWindowText( "" );
 	}
}

void CTestLFPProtocolView::MSGShow( BOOL bshow )
{
	m_bshowmsg = bshow;
}

void CTestLFPProtocolView::OnInitialUpdate()
{
	CFormView::OnInitialUpdate();
	GetParentFrame()->RecalcLayout();
	ResizeParentToFit();

	MainInit();
	ReadConfig();
	dev_addr = startaddr;
}

void CTestLFPProtocolView::MainInit( void )
{
	m_bInit = TRUE;
	m_bEnable = TRUE;
	m_pThread = NULL;
	m_bConnected = FALSE;
	m_bSYN = FALSE;
	m_BufferSize = 0;
	m_nState = NSAS_SYNC;
	m_nCount = 0;
	m_nFrameCount = 0;
	m_nFramePoll = 0;
	m_nCurFrame = 0;
	m_nSendPoint = 0;
	m_nPollCount = 0;
	m_nSendTime = 0;

	m_bshowmsg = FALSE;
	m_bIsC35Frame = FALSE;
	m_bPolling = FALSE;
	m_bPoll = FALSE;
	dev_addr = startaddr;
	aivalue_num = 0;
	divalue_num = 0;

	CTestLFPProtocolApp *pApp = ( CTestLFPProtocolApp * )AfxGetApp();
	pApp->m_pMainView = this;

	memset( &dev_ctrl, 0, sizeof( struDevCtrl ) );
	memset( &dev_settingvalue_type, 0, sizeof( dev_settingvalue_type ) );
	memset( &m_devtype, 0, sizeof( struDevType ) );
	memset( &m_recebuffer, 0, sizeof( struRecBuf ) );
	memset( &m_osRead, 0, sizeof( OVERLAPPED ));
	memset( &m_osWrite, 0, sizeof( OVERLAPPED ));
	if( ( m_hPostMsgEvent = CreateEvent( NULL, TRUE, TRUE, NULL ) ) == NULL )
		AfxMessageBox( "为WM_COMMNOTIFY消息创建事件对象失败！" );
	if( ( m_osRead.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL ) ) == NULL )
		AfxMessageBox( "为重叠读创建事件对象失败！" );
	if( ( m_osWrite.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL ) ) == NULL )
		AfxMessageBox( "为重叠写创建事件对象失败！" );
	
	memset( &RichEditFormat, 0, sizeof( CHARFORMAT ) );
	RichEditFormat.cbSize = sizeof(CHARFORMAT);
	RichEditFormat.dwMask |=  CFM_COLOR;				//启用前景色
	RichEditFormat.dwEffects &= ~CFE_AUTOCOLOR;		//关闭自动文字颜色
	RichEditFormat.dwMask |= CFM_SIZE;				//开启文字大小设置
	RichEditFormat.dwMask |=  CFM_FACE;				//开启字体名设置
	RichEditFormat.yHeight = 240;						//设置高度
	strcpy( RichEditFormat.szFaceName, _T("宋体") );	//设置字体

	CRect rect;
	GetClientRect( rect );
	m_MSG.MoveWindow( rect );
}
/////////////////////////////////////////////////////////////////////////////
// CTestLFPProtocolView printing

BOOL CTestLFPProtocolView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

void CTestLFPProtocolView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

void CTestLFPProtocolView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

void CTestLFPProtocolView::OnPrint(CDC* pDC, CPrintInfo* /*pInfo*/)
{
	// TODO: add customized printing code here
}

/////////////////////////////////////////////////////////////////////////////
// CTestLFPProtocolView diagnostics

#ifdef _DEBUG
void CTestLFPProtocolView::AssertValid() const
{
	CFormView::AssertValid();
}

void CTestLFPProtocolView::Dump(CDumpContext& dc) const
{
	CFormView::Dump(dc);
}

CTestLFPProtocolDoc* CTestLFPProtocolView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CTestLFPProtocolDoc)));
	return (CTestLFPProtocolDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CTestLFPProtocolView message handlers

void CTestLFPProtocolView::OnAppComSetting() 
{
	// TODO: Add your command handler code here
	CComSetting	dlg;
	dlg.m_bConnected = m_bConnected;
	strcpy( dlg.m_strComNo, strComNo );
	sprintf( dlg.m_strBaudRate, "%d", dwBaudRate );
	sprintf( dlg.m_strDataSize, "%d", DataSize );
	dlg.m_Stop = StopBit;
	dlg.m_Parity = Parity;
	if( dlg.DoModal() == IDOK ) {
		strcpy( strComNo, dlg.m_strComNo );
		dwBaudRate = (DWORD)atoi( dlg.m_strBaudRate );
		DataSize = (BYTE)atoi( dlg.m_strDataSize );
		StopBit = dlg.m_strStopBit;
		Parity = dlg.m_strParity;
	}	
}

void CTestLFPProtocolView::OnAppComConnect() 
{
	// TODO: Add your command handler code here
	if( InitComm() ) {
		SetTimer( PROTOCOL_POLL, 10, NULL );
		SetTimer( PROTOCOL_RUN, 100, NULL );
		SetTimer( WAIT_TIME, 1000, NULL );
		m_bIsC35Frame = FALSE;
		CTestLFPProtocolApp *pApp = ( CTestLFPProtocolApp* )AfxGetApp();
		pApp->m_pMainFrame->TreeRootInit();
	}
}

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

void CTestLFPProtocolView::OnAppComDisconnect() 
{
	// TODO: Add your command handler code here
	CloseComm();
	KillTimer( PROTOCOL_RUN );
	KillTimer( PROTOCOL_POLL );
	KillTimer( WAIT_TIME );
}

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

DWORD CTestLFPProtocolView::WriteCommData( BYTE* buffer, DWORD dwLength )
{
	BOOL	fState;
	DWORD	length = dwLength;
	COMSTAT	ComStat;
	DWORD	dwErrorFlags;

	ClearCommError( m_hCom, &dwErrorFlags, &ComStat );
	fState = WriteFile( m_hCom, buffer, length, &length, &m_osWrite );
	if( !fState ) {
		if( GetLastError() == ERROR_IO_PENDING ) {
			GetOverlappedResult( m_hCom, &m_osWrite, &length, TRUE );// 等待
		}
		else length = 0;
	}
	return length;
}

DWORD CTestLFPProtocolView::ReadCommData( BYTE* buffer, DWORD dwLength )
{
	COMSTAT	ComStat;
	DWORD	length;
	DWORD	dwErrorFlags;
	ClearCommError( m_hCom, &dwErrorFlags, &ComStat );
	length = min( dwLength, ComStat.cbInQue );
	ReadFile( m_hCom, buffer, length, &length, &m_osRead );
	return length;
}

BOOL CTestLFPProtocolView::InitComm()
{
	COMMTIMEOUTS	TimeOuts;
	char	InitComNo[32] = "\\\\.\\";
	strcat( InitComNo, strComNo );
	m_hCom = CreateFile(
		InitComNo,
		GENERIC_READ | GENERIC_WRITE,
		0,
		NULL,
		OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
		NULL );		// 重叠方式

	if( m_hCom == INVALID_HANDLE_VALUE ) {
		AfxMessageBox( "串口打开失败！" );
		return FALSE;
	}

	SetupComm( m_hCom, 1024, 1024 );
	SetCommMask( m_hCom, EV_RXCHAR );

	/* 把间隔超时设为最大，把总超时设为0将导致ReadFile立即返回并完成操作*/
	TimeOuts.ReadIntervalTimeout = MAXDWORD; 
	TimeOuts.ReadTotalTimeoutMultiplier = 0; 
	TimeOuts.ReadTotalTimeoutConstant = 0; 

	/* 设置写超时以指定WriteComm成员函数中的GetOverlappedResult函数的等待时间*/
	TimeOuts.WriteTotalTimeoutMultiplier = 50;
	TimeOuts.WriteTotalTimeoutConstant = 2000;

	SetCommTimeouts( m_hCom, &TimeOuts );

	DCB	dcb ;						// 定义数据控制块结构
	GetCommState( m_hCom, &dcb );	//读串口原来的参数设置
	dcb.BaudRate = dwBaudRate;
	dcb.ByteSize = DataSize; 
	dcb.Parity = Parity;
	dcb.StopBits = StopBit ;
	dcb.fBinary = TRUE ;
	dcb.fParity = FALSE;
	if( SetCommState( m_hCom, &dcb ) ) {
		m_pThread = AfxBeginThread(
			masterlfpproto,
			this,
			THREAD_PRIORITY_NORMAL,
			0,
			CREATE_SUSPENDED,
			NULL );					// 创建并挂起线程
		if( m_pThread == NULL ) {
			CloseHandle( m_hCom );
			AfxMessageBox( "线程未能启动！" );
			return FALSE;
		}
		else {
			m_bConnected = TRUE;
			m_pThread->ResumeThread(); // 恢复线程运行
		}
	}
	else {
		CloseHandle( m_hCom );
		AfxMessageBox( "串口配置错误！" );
		return FALSE;
	}
	return TRUE;
}

void CTestLFPProtocolView::CloseComm()
{
	m_bConnected = FALSE;

	/*结束CommProc线程中WaitSingleObject函数的等待*/
	SetEvent( m_hPostMsgEvent ); 

	/*结束CommProc线程中WaitCommEvent的等待*/
	SetCommMask( m_hCom, 0 ); 

	/*等待辅助线程终止*/
	WaitForSingleObject( m_pThread->m_hThread, INFINITE );
	m_pThread = NULL;
	CloseHandle( m_hCom );
}

LRESULT CTestLFPProtocolView::MasterReceive( WPARAM wParam, LPARAM lParam )
{

	int		nLength = -1;
	int		m_start = 0;
	BYTE*	pData = NULL;
	WORD	checkSum;
	DWORD	m_dwOld_Count = 0;
	if( !m_bConnected || ( wParam & EV_RXCHAR ) != EV_RXCHAR ) {	// 是否是EV_RXCHAR事件?
		SetEvent( m_hPostMsgEvent );								// 允许发送下一个WM_COMMNOTIFY消息
		return 0L;
	}
	nLength = ReadCommData( &m_recebuffer.buffer[m_recebuffer.count], MAX_SIZE - m_recebuffer.count );
	if( nLength <= 0 ) {
		SetEvent( m_hPostMsgEvent );
		return 0L;
	}
	m_recebuffer.count += nLength;
	m_dwOld_Count = m_recebuffer.count;
	
	if( m_recebuffer.count <= 0 || m_recebuffer.count > MAX_SIZE ) {
		SetEvent( m_hPostMsgEvent );
		return 0L;
	}
	while( m_recebuffer.count >= NSAP_NEED_SIZE ) {
		m_start = m_dwOld_Count - m_recebuffer.count;
		pData = &m_recebuffer.buffer[m_start];
		if( m_bSYN == FALSE ) {
			if( IsSYN( pData ) ) {
				m_BufferSize = pData[9];
				m_bSYN = TRUE;
			}
			else {
				m_recebuffer.count--;
			}
			continue;
		}
		if( m_bSYN == TRUE ) {
			if( m_recebuffer.count < m_BufferSize+9 ) {
				SetEvent( m_hPostMsgEvent );
				return 0L;
			}
			checkSum = pData[m_BufferSize+7];
			checkSum <<= 8; checkSum &= 0xff00;
			checkSum += pData[m_BufferSize+6];
			if( checkSum != GetCheckSum16( &pData[5], pData[9]+1 ) ||
				pData[m_BufferSize+8] != NSAC_ETX ) {
				m_recebuffer.count -= m_BufferSize+9;
				SetEvent( m_hPostMsgEvent );
				return 0L;
			}
			RichEditFormat.crTextColor = RGB( 0, 0, 255 );
			ShowMSG( pData, 9+m_BufferSize, FALSE );
			m_recebuffer.count -= m_BufferSize+9;
			if( MainProc( &pData[5], pData[9]+1 ) ) {
				m_nCurFrame = 0;
			}
			m_bSYN = FALSE;
		}
	}
	
	if( m_recebuffer.count <= 0 || m_recebuffer.count > MAX_SIZE ) {
		m_recebuffer.count = 0;
		SetEvent( m_hPostMsgEvent );
		return 0L;
	}
	if( m_recebuffer.count == 0 ) {
		SetEvent( m_hPostMsgEvent );
		return 0L;
	}
 	m_start = m_dwOld_Count - m_recebuffer.count;
 	if( m_start == 0 ) {
 		SetEvent( m_hPostMsgEvent );
 		return 0L;
 	}