mbpcdoc.cpp

保护装置的mbpc软件

// mbpcDoc.cpp : implementation of the CMbpcDoc class
//

#include "stdafx.h"
#include "mbpc.h"
#include   <fstream.h>
#include "mbpcDoc.h"
#include "ConfigDlg.h"
#include "MainFrm.h"
#include "process.h"

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

/////////////////////////////////////////////////////////////////////////////
// CMbpcDoc

IMPLEMENT_DYNCREATE(CMbpcDoc, CDocument)

BEGIN_MESSAGE_MAP(CMbpcDoc, CDocument)
	//{{AFX_MSG_MAP(CMbpcDoc)
	ON_COMMAND(ID_CONNECT, OnConnect)
	ON_COMMAND(ID_DISCONNECT, OnDisconnect)
	ON_UPDATE_COMMAND_UI(ID_CONNECT, OnUpdateConnect)
	ON_UPDATE_COMMAND_UI(ID_DISCONNECT, OnUpdateDisconnect)
	ON_COMMAND(ID_CONFIG, OnConfig)
	ON_COMMAND(ID_TEST, OnTest)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CMbpcDoc construction/destruction

CMbpcDoc::CMbpcDoc()
{
	// TODO: add one-time construction code here
	
	this->InfoInit();
	this->ValueInit();
	m_nSetFrameNum = 0;
	m_nSetFrameCntr = 0;
	m_bSetuped = FALSE;
	m_bSetSaved = TRUE;
	m_bLogIn = FALSE;
	m_pComThread = NULL;
	this->m_nRemoteAddr = REMOTE_ADDRESS;
	this->ReadConfigFile();
}

CMbpcDoc::~CMbpcDoc()
{
}

BOOL CMbpcDoc::OnNewDocument()
{
	if (!CDocument::OnNewDocument())
		return FALSE;

	((CEditView*)m_viewList.GetHead())->SetWindowText(NULL);

	// TODO: add reinitialization code here
	// (SDI documents will reuse this document)
	
	CConfigDlg dlg;
	CString str;
	if(dlg.DoModal() == IDOK)
	{
		sprintf(m_szPort,"%s",dlg.m_szPort);
		this->SetupConnection(m_szPort);
	}
	
	
	return TRUE;
}



/////////////////////////////////////////////////////////////////////////////
// CMbpcDoc serialization

void CMbpcDoc::Serialize(CArchive& ar)
{
	// CEditView contains an edit control which handles all serialization
//	((CEditView*)m_viewList.GetHead())->SerializeRaw(ar);

	m_ObjList.Serialize(ar);
	if (ar.IsStoring())
	{
		
	}
	else
	{
		
	}
	UpdateAllViews(NULL);
}

/////////////////////////////////////////////////////////////////////////////
// CMbpcDoc diagnostics

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

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

/////////////////////////////////////////////////////////////////////////////
// CMbpcDoc commands

void CMbpcDoc::OnConnect() 
{
	// TODO: Add your command handler code here
	this->SetupConnection(m_szPort);
}

void CMbpcDoc::OnDisconnect() 
{
	// TODO: Add your command handler code here
	if( m_bSetuped == FALSE)
	{
		AfxMessageBox("Comm has not been opened");
	}
	else
	{
		this->m_nMsgtype = 0;
		this->CloseConnection();
	}
}

BOOL CMbpcDoc::SetupConnection(char szPort[20])
{
	DCB        dcb ;
	DWORD dwError;
	COMMTIMEOUTS comm_timeout;
	if(m_bSetuped)
	{
		
	}
	else
	{
		this->m_pComThread = (CComThread*)AfxBeginThread(RUNTIME_CLASS(CComThread) , THREAD_PRIORITY_NORMAL , 1024 , CREATE_SUSPENDED);
		m_pComThread->m_bAutoDelete = TRUE;

		m_pComThread->m_osWrite.Offset=0;
		m_pComThread->m_osWrite.OffsetHigh = 0;
		m_pComThread->m_osRead.Offset = 0;
		m_pComThread->m_osRead.OffsetHigh = 0;
		m_pComThread->m_osWrite.hEvent = CreateEvent( NULL,    // no security
													   TRUE,    // explicit reset req
													   FALSE,   // initial event reset
													   NULL ) ; // no name

		m_pComThread->m_osRead.hEvent = CreateEvent( NULL,    // no security
													   TRUE,    // explicit reset req
													   FALSE,   // initial event reset
													   NULL ) ; // no name

		m_pComThread->m_hCommDev =  CreateFile( szPort, 
							GENERIC_READ | GENERIC_WRITE,
							0,                    // exclusive access
							NULL,                 // no security attrs
							OPEN_EXISTING,
							FILE_ATTRIBUTE_NORMAL |	FILE_FLAG_OVERLAPPED, // overlapped I/O
							NULL );
		dwError = GetLastError();
		if(dwError != 0)
		{
			AfxMessageBox("Can not open COM,check COM port");
			return ( FALSE );
		}
		//if((m_pComThread->m_hCommDev) == ((HANDLE) - 1)) 
		//	{
		//		return ( FALSE ) ;
		//	}
		else
		{
			  SetCommMask( m_pComThread->m_hCommDev, EV_RXCHAR ) ;

			  SetupComm( m_pComThread->m_hCommDev, 4096, 4096 ) ;

			  PurgeComm( m_pComThread->m_hCommDev, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR ) ;

			  comm_timeout.ReadIntervalTimeout = 0xffffffff;
			  comm_timeout.ReadTotalTimeoutMultiplier = 0 ;
			  comm_timeout.ReadTotalTimeoutConstant = 0 ;
			  comm_timeout.WriteTotalTimeoutMultiplier = 0 ;
			  comm_timeout.WriteTotalTimeoutConstant = 0 ;
			  SetCommTimeouts( m_pComThread->m_hCommDev, &comm_timeout );
		}
			
		dcb.DCBlength = sizeof( DCB );

		GetCommState(m_pComThread->m_hCommDev, &dcb );

		dcb.BaudRate = CBR_4800;
		dcb.ByteSize = 8 ;
		dcb.Parity = NOPARITY ;
		dcb.StopBits = ONESTOPBIT ;

		// other various settings
		dcb.fBinary = TRUE ;

		m_pComThread->m_bConnected = SetCommState(m_pComThread->m_hCommDev, &dcb ) ;
		m_pComThread->m_pDoc = this;
		if(m_pComThread->m_bConnected)
		{
			m_pComThread->ResumeThread();
		}
		m_bSetuped = m_pComThread->m_bConnected;
	}
		return m_bSetuped;
}

BOOL CMbpcDoc::CloseConnection()
{
	SetCommMask( m_pComThread->m_hCommDev, 0 );

	CloseHandle( m_pComThread->m_hCommDev );
	
	m_pComThread->m_bConnected = FALSE;
	
	m_bSetuped = FALSE;

	m_pComThread = NULL;

	return TRUE;
}

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

void CMbpcDoc::OnUpdateDisconnect(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	pCmdUI->Enable(m_bSetuped);
}

void CMbpcDoc::OnConfig() 
{
	// TODO: Add your command handler code here
	CConfigDlg dlg;
	CString str;
	if(dlg.DoModal() == IDOK)
	{
		sprintf(m_szPort,"%s",dlg.m_szPort);
	}
}

void CMbpcDoc::OnTest() 
{
	// TODO: Add your command handler code here
//	this->InfoInit();
//	this->ValueInit();
	this->BeginWaitCursor();
	ReqInfo();
	this->EndWaitCursor();
}

void CMbpcDoc::ReqDeviceinfo()
{
	BYTE tSum = 0, tBuf[12];
	DWORD data_written;

	memset(tBuf,0,sizeof(tBuf));

	tBuf[0] = 0xeb; tBuf[1] = 0x90; tBuf[2] = m_nRemoteAddr;
	tBuf[3] = LOCAL_ADDRESS; tBuf[4] = 0x09; tBuf[5] = 0x00; tBuf[6] = PROT_PRIM_VERSION;
	tBuf[7] = PROT_SCND_VERSION; tBuf[8] = REQ_DEVICE_INFO; 
	
	for(int i = 0; i < 9; i++)
	{
		tSum += tBuf[i];
	}
	tBuf[9] = tSum; tBuf[10] = 0xd7; tBuf[11] = 0x09;

	WriteFile(m_pComThread->m_hCommDev, tBuf, 12, &data_written, &m_pComThread->m_osWrite);
}

void CMbpcDoc::ReqInfo()
{	
	if(m_bSetuped == TRUE)
	{
		CMainFrame *pFrame = (CMainFrame*)AfxGetMainWnd();
		BOOL tFlag = TRUE;
		int timecntr = 0;
		m_nNeedMsg = ACK_DEVICE_INFO;
		m_bArrived = FALSE;
		ReqDeviceinfo();

		
		//pFrame->m_wndStatusBar.SetMode(0,XSB_PROGRESS | XSB_SMOOTH);
		//pFrame->m_wndStatusBar.SetRange(0, 0, 100);
		BOOL tStatus = 1;
		int step = 0;
		while(tStatus)
		{	
			if(m_bArrived)
			{
				switch (step)
				{
				case 0:
					{
						m_nNeedMsg = ACK_ANALOG_INFO;
						m_bArrived = FALSE;
						if(tFlag == TRUE)
						{
							tFlag = this->ReqAnaloginfo(m_device_info.analog_count);
							step++;
						}
						else
						{
							tStatus = 0;
						}
						
						break;
					}
				case 1:
					{ 
						m_nNeedMsg = ACK_METER_INFO;
						m_bArrived = FALSE;
						if(tFlag == TRUE)
						{
							tFlag = ReqMeterInfo(m_device_info.energy_count);
							step++;
						}
						else
						{
							tStatus = 0;
						}
						break;
					}
				case 2:
					{
						m_nNeedMsg = ACK_DI_INFO;
						m_bArrived = FALSE;
						if(tFlag == TRUE)
						{
							tFlag = ReqDiInfo(m_device_info.di_count);
							step++;
						}
						else
						{
							tStatus = 0;
						}
						break;
					}
				case 3:
					{
						m_nNeedMsg = ACK_DO_INFO;
						m_bArrived = FALSE;
						if(tFlag == TRUE)
						{
							tFlag = ReqDoInfo(m_device_info.do_count);
							step++;
						}
						else
						{
							tStatus = 0;
						}
						break;
					}
				case 4:
					{
						m_nNeedMsg = ACK_ENABLE_INFO;
						m_bArrived = FALSE;
						if(tFlag == TRUE)
						{
							tFlag = ReqEnableInfo(m_device_info.enable_count);
							step++;
						}
						else
						{
							tStatus = 0;
						}
						break;
					}
				case 5:
					{
						m_nNeedMsg = ACK_ALARM_INFO;
						m_bArrived = FALSE;
						if(tFlag == TRUE)
						{
							tFlag = ReqAlarmInfo(m_device_info.alarm_count);
							step++;
						}
						else
						{
							tStatus = 0;
						}
						break;
					}
				case 6:
					{
						m_nNeedMsg = ACK_RECORD_INFO;
						m_bArrived = FALSE;
						if(tFlag == TRUE)
						{
							tFlag = ReqRecordInfo(m_device_info.act_count);
							step++;
						}
						else
						{
							tStatus = 0;
						}
						break;
					}
				case 7:
					{
						m_nNeedMsg = ACK_SETTING_INFO;
						m_bArrived = FALSE;
						if(tFlag == TRUE)
						{
							tFlag = ReqSettingInfo(m_device_info.item_in_sect);
//							step++;
							tStatus = 0;
						}
						break;
					}
				}
			}
			else
			{
				Sleep(10);
				timecntr++;
				if(timecntr == 500)
				{
					tStatus = 0;
				}
			}
		}
		if((timecntr < 100)&&(tFlag == TRUE))
		{
			AfxMessageBox("Succeed");
			WriteConfigFile();
		}
		else
		{
			AfxMessageBox("Time out");
			pFrame->SetMessageText("通信超时");
			m_pComThread->m_nTimeCntr = 60;
		}
	}

	else
	{
		AfxMessageBox("Com port has not been opened,check it");
	}
}

BOOL CMbpcDoc::ReqAnaloginfo(BYTE count)
{  
	Sleep(100);
	int timecntr = 0;
	BYTE tSum = 0, tBuf[13],tId,tIdBuf;
	DWORD data_written;
	tId = 0;
	tIdBuf = 254;
	memset(tBuf, 0, sizeof(tBuf));
	while(tId < count)
	{	
		if(timecntr < 100)
		{
			if(tIdBuf != m_cId)
			{	
				tSum = 0;
				tIdBuf = m_cId;
				tBuf[0] = 0xeb; tBuf[1] = 0x90; tBuf[2] = m_nRemoteAddr;
				tBuf[3] = LOCAL_ADDRESS; tBuf[4] = 0x0a; tBuf[5] = 0x00; tBuf[6] = PROT_PRIM_VERSION;
				tBuf[7] = PROT_SCND_VERSION; tBuf[8] = REQ_ANALOG_INFO; tBuf[9] = tId;
				for(int i = 0; i < 10; i++)
				{
					tSum += tBuf[i];
				}
				tBuf[10] = tSum; tBuf[11] = 0xd7; tBuf[12] = 0x09;

				WriteFile(m_pComThread->m_hCommDev, tBuf, 13, &data_written, &m_pComThread->m_osWrite);
				tId++;
				timecntr = 0;
			}
			else
			{
				Sleep(10);
				timecntr++;
				if((timecntr == 30)||(timecntr == 60)||(timecntr == 90))
				{
					WriteFile(m_pComThread->m_hCommDev, tBuf, 13, &data_written, &m_pComThread->m_osWrite);
				}
			}
		}
		else
		{
			AfxMessageBox("REQ AnalogInfo time out");
			tId = 100;
			return FALSE;
		}
	}
	Sleep(200);
	if(m_cId == count - 2)
	{
		WriteFile(m_pComThread->m_hCommDev, tBuf, 13, &data_written, &m_pComThread->m_osWrite);
	}
	return TRUE;
}

BOOL CMbpcDoc::ReqMeterInfo(BYTE count)
{
	Sleep(500);
	int timecntr = 0;
	BYTE tSum = 0, tBuf[13],tId,tIdBuf;
	DWORD data_written;