jhhbdoc.cpp

环保局污染设备在线控制系统

	return  (dFLOWNumber - nFLOWBOT) * (nFLOWTOP - nFLOWBOT) / (nFLOWTOP - nFLOWBOT) + nFLOWBOT;
}

double	CJHHBDoc::CalcNH4NValue(int  nStation, WORD  nNH4NNubmer)
{
	double	dNH4NNumber = (double)nNH4NNubmer;

	double	nNH4NTOP;
	double	nNH4NBOT;
	if (m_bUseDao)	// DAO
	{
		m_pDaoStationInfoSet->MoveFirst();
		for (int  i = 1; i < nStation ; ++ i)
		{
			m_pDaoStationInfoSet->MoveNext();
		}
		nNH4NTOP = m_pDaoStationInfoSet->m_nNH4NTOP;
		nNH4NBOT = m_pDaoStationInfoSet->m_nNH4NBOT;
	}
	else	// ODBC
	{
		m_pStationInfoSet->MoveFirst();
		for (int  i = 1; i < nStation; ++ i)
		{
			m_pStationInfoSet->MoveNext();
		}
		nNH4NTOP = m_pStationInfoSet->m_nNH4NTOP;
		nNH4NBOT = m_pStationInfoSet->m_nNH4NBOT;
	}
	if (dNH4NNumber < nNH4NBOT)
		dNH4NNumber = nNH4NBOT;		

	return  (dNH4NNumber - nNH4NBOT) * (nNH4NTOP - nNH4NBOT) / (nNH4NTOP - nNH4NBOT) + nNH4NBOT;
}
//---------------------- ljh end

void	CJHHBDoc::ParseData(void)
{
/*
	Type          Content
-------------------------------
	BYTE          'B'
	BYTE          'E'
	BYTE          'G'
	BYTE          'I'
	BYTE          'N'
	WORD          length = n+11
	BYTE          station
	BYTE          PH_data[0]
	...
	BYTE          PH_data[n-1]

	BYTE          'E'
	BYTE          'N'
	BYTE          'D'

*/

	TRACE0("Parse Data !\n");
	CWaitCursor	wait;
	
	BYTE*	pDataBuf = m_pGetDataBuf + 5;
	
	int	nDataLen = *(WORD*)pDataBuf;
	pDataBuf += sizeof(WORD);

	int	nStation = (int)*pDataBuf;
	pDataBuf += sizeof(BYTE);

	//	ASSERT(nStation == CCtrlInfoObject::m_nCurWorkStation);
	if (nStation != CCtrlInfoObject::m_nCurWorkStation)
	{
			TRACE0("Error on station number !\n");
			GetLogView()->AddNewLog(_T("Error: it is defferent in Station and CurWorkStation."));
			return ;
	}//add 1999-10-29
	int	nPHNumber = nDataLen - 11;

	//------------------- ljh begin
    int nCODNumber = 8;
	int nFLOWNumber = 8;
	int nNH4NNumber = 8;
	//------------------- ljh end
	CTime	timeConclude;

	if ( nPHNumber > 0 )
		timeConclude = CTime::GetCurrentTime() - CTimeSpan(0, 0,( nPHNumber - 1) * nTimeSpan, 0);
	else
		timeConclude = CTime::GetCurrentTime();

	int nYear   = timeConclude.GetYear() ;
	int nMonth  = timeConclude.GetMonth();
	int nDay    = timeConclude.GetDay();
	int nHour   = timeConclude.GetHour();
	int nMinute = (timeConclude.GetMinute() / 10 )*10;

	// ASSERT if indicates an illegal input time
	 
	CTime	time(nYear, nMonth, nDay, nHour, nMinute, 0);

	CString	strInfo;
	strInfo.Format(IDS_LOGRECEIVE, m_ctrlInfoArray[nStation - 1]->GetStationName(), nPHNumber);
	GetLogView()->AddNewLog(strInfo);

	if (m_bUseDao)
	{
		m_pDaoAddDataSet->GenParam(COleDateTime(time.GetYear(), time.GetMonth(), time.GetDay(), 0, 0, 0), nStation);
		try
		{
			m_pDaoAddDataSet->Requery();
		}
		catch (CDaoException* e)
		{
			DisplayDaoException(e);
			e->Delete();
			return;
		}
	}
	else
	{
		m_pAddDataSet->GenParam(COleDateTime(time.GetYear(), time.GetMonth(), time.GetDay(), 0, 0, 0), nStation);
		try
		{
			m_pAddDataSet->Requery();
		}
		catch (CDBException* e)	
		{
			e->Delete();
			return;
		}
	}
	GenSpeedArray();

	for (int  i = 0; i < nPHNumber; ++ i)
	{
//		AddSampleData(nStation, time, *pDataBuf ++);  // ljh del
        AddSampleData(nStation, time, *pDataBuf ++, *pDataBuf ++, *pDataBuf ++, *pDataBuf ++); //ljh add
		time += CTimeSpan(0, 0, nTimeSpan, 0); // add span minutes exactly

		if (nDay != time.GetDay())	// to next day, need Requery
		{
			nDay = time.GetDay();

			if (m_bUseDao)
			{
				m_pDaoAddDataSet->GenParam(COleDateTime(time.GetYear(), time.GetMonth(), time.GetDay(), 0, 0, 0), nStation);
				try
				{
					m_pDaoAddDataSet->Requery();
				}
				catch (CDaoException*  e)
				{
					DisplayDaoException(e);
					e->Delete();
				}
			}
			else
			{
				m_pAddDataSet->GenParam(COleDateTime(time.GetYear(), time.GetMonth(), time.GetDay(), 0, 0, 0), nStation);
				m_pAddDataSet->Requery();
			}
			GenSpeedArray();
		}
	}
	CTime	t = CTime::GetCurrentTime();
	COleDateTime	today(t.GetYear(), t.GetMonth(), t.GetDay(), 0, 0, 0);
	if (m_curSpyTime == today)
	{
		RefreshData(today);
		UpdateAllViews(NULL);
	}

	if (m_pSpeedQueryArray != NULL)
	{
		delete  m_pSpeedQueryArray;
		m_pSpeedQueryArray = NULL;
	}
	::Sleep(500);			//Delay 500 ms to avoid communication signal jam
	SendOKString(nStation);
}

void	CJHHBDoc::SendRequestString(int  nStation, CTime&  time)
{
	ASSERT(m_ctrlInfoArray[nStation - 1]->m_status == CCtrlInfoObject::COMM_STATUS_IDLE);

	ASSERT(m_pComm != NULL);
	if (!m_pComm->m_bConnected)
		if (m_pComm->OpenConnection() == FALSE)
			ASSERT(FALSE);

	m_strSend = _T("");
	m_strSend += (TCHAR)nStation;
	m_strSend += (TCHAR)(time.GetYear() % 100); 
	m_strSend += (TCHAR)time.GetMonth();
	m_strSend += (TCHAR)time.GetDay();
	m_strSend += (TCHAR)time.GetHour();
	m_strSend += (TCHAR)time.GetMinute();

	CString	strEnd;
	strEnd.LoadString(IDS_COMMENDTOKEN);

	m_strSend += strEnd;

	CString	strInfo;
	strInfo.Format(IDS_LOGSENDREQUEST, m_ctrlInfoArray[nStation - 1]->GetStationName());
	GetLogView()->AddNewLog(strInfo);

	CJHHBDoc*	pJHHBDoc = (CJHHBDoc*)((CMainFrame*)::AfxGetApp()->m_pMainWnd)->GetActiveDocument();//2001年6月1日增
	pJHHBDoc->m_nCurStation=nStation;//2001年6月1日增

	m_pComm->WriteCommBlock(m_strSend, m_strSend.GetLength());

	m_bAutoActivated = TRUE;

	CCtrlInfoObject::m_nCurWorkStation = nStation;

	// To refresh the semaphore on status_bar 
	((CMainFrame*)::AfxGetApp()->m_pMainWnd)->RefreshStatusBar();

	m_ctrlInfoArray[nStation - 1]->m_lastTime = time;
	m_ctrlInfoArray[nStation - 1]->m_status = CCtrlInfoObject::COMM_STATUS_WAITREPLY;
	m_nReceiveCount = 0;
	m_nTotalReceive = 0;
}

void	CJHHBDoc::SendOKString(int  nStation)
{
	ASSERT(CCtrlInfoObject::m_nCurWorkStation == nStation);
	ASSERT(m_ctrlInfoArray[nStation - 1]->m_status == CCtrlInfoObject::COMM_STATUS_TRANSDATA);

	ASSERT(m_pComm != NULL);
	if (!m_pComm->m_bConnected)
		if (m_pComm->OpenConnection() == FALSE)
			ASSERT(FALSE);

	m_strSend = _T("");
	m_strSend += (TCHAR)nStation;

	CString	strOK;
	strOK.LoadString(IDS_COMMOKTOKEN);
	m_strSend += strOK;

	CString	strEnd;
	strEnd.LoadString(IDS_COMMENDTOKEN);
	m_strSend += strEnd;

	CString	strInfo;
	strInfo.Format(IDS_LOGSENDOK, m_ctrlInfoArray[nStation - 1]->GetStationName());
	GetLogView()->AddNewLog(strInfo);

	m_pComm->WriteCommBlock(m_strSend, m_strSend.GetLength());
	
	::Sleep(500);			//Delay 500 ms to avoid communication signal jam
	CCtrlInfoObject::m_nCurWorkStation = -1;

	m_ctrlInfoArray[nStation - 1]->m_lastTime = CTime::GetCurrentTime();
	m_ctrlInfoArray[nStation - 1]->m_bCommSuccess = TRUE;
	m_timeLast= CTime::GetCurrentTime();
	m_ctrlInfoArray[nStation - 1]->m_status = CCtrlInfoObject::COMM_STATUS_IDLE;
	// To refresh the semaphore on status_bar 
	((CMainFrame*)::AfxGetApp()->m_pMainWnd)->RefreshStatusBar();
}


void CJHHBDoc::OnUpdateDataRequestsend(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(CCtrlInfoObject::m_nCurWorkStation == -1);	
}
void CJHHBDoc::OnUpdateDataRelayReal(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(CCtrlInfoObject::m_nCurWorkStation == -1);	
}

#include "SeleStationDlg.h"
void CJHHBDoc::OnDataRequestsend() 
{
	CSeleStationDlg	dlg(&(m_ctrlInfoArray));
	if (dlg.DoModal() == IDOK)
	{
		CTime	t = CTime::GetCurrentTime();
		SendRequestString(dlg.m_nSeleStation, t);
	}
}

#include "RealDlg.h"
void CJHHBDoc::OnDataRelayReal() 
{
	m_nReceiveCount=0;
	m_bRelayActivated=TRUE;
	CSeleStationDlg	dlg(&(m_ctrlInfoArray));
	if (dlg.DoModal() == IDOK)
	{
		CRealDlg dlgRealDlg(dlg.m_nSeleStation,m_pComm);
		m_pdlgReal=&dlgRealDlg;
		dlgRealDlg.DoModal();
		m_pdlgReal=NULL;
	}
	m_bRelayActivated=FALSE;
	m_nReceiveCount=0;
}

void CJHHBDoc::OnCommSettings() 
{
	CCommSettingsDlg	dlg;
	if (dlg.DoModal() == IDOK)
	{
		if (m_pComm != NULL)
		{
			delete  m_pComm;
		}

		m_pComm = new  CCommInfo;
		m_pComm->Create(
			NULL,
			CM_COMM,
			m_pReadCommBuf,
			cMaxReadCommBufLen - sizeof(WORD),
			dlg.GetCommPort(),
			dlg.GetBaudRate(),
			dlg.GetFlowCtrls(),
			dlg.GetDataBits(),
			dlg.GetStopBits(),
			dlg.GetParity(),
			TRUE	// special
			);

		if (m_pComm->OpenConnection() == FALSE)
		{
			::AfxMessageBox(IDS_ERRCOMMCONNECT, MB_OK | MB_ICONSTOP);
		}
	}
}


#include "StationCtrlDlg.h"
void CJHHBDoc::OnStationSetup()
{
	CStationCtrlDlg	dlg(&(m_ctrlInfoArray));
	if (dlg.DoModal() == IDOK)
	{
		// Save the result and refresh the spy
		//int	nCurSel = m_Spy.GetCurSelNO(GetDocument()->m_ctrlInfoArray);
		int	nCurSel = m_ctrlInfoArray[m_nCurStation]->GetAbsCurSel(m_ctrlInfoArray);
		BOOL	bRedraw;

		//ASSERT(m_ctrlInfoArray[nCurSel]->m_bActive == TRUE);
		if (dlg.m_stationCtrlList.m_isCheckedArray[nCurSel] == FALSE)
		{
			// current select tab is shut !
			bRedraw = TRUE;
		}
		else
		{
			bRedraw = FALSE;
		}

		for (int  n = 0; n < m_ctrlInfoArray.GetSize(); ++ n)
		{
			CCtrlInfoObject*	pCtrlInfo = m_ctrlInfoArray[n];
			pCtrlInfo->m_bActive = dlg.m_stationCtrlList.m_isCheckedArray[n];
		}
		GetJHHBView()->m_Spy.UpdateTab(m_ctrlInfoArray);
//		UpdateAllViews(NULL);

		if (bRedraw)
		{
			LRESULT	lTemp;
			GetJHHBView()->OnStationSelChange(NULL, &lTemp);
		}
		else
		{
			for (int  n = 0; n < m_ctrlInfoArray.GetSize(); ++ n)
			{
				if (m_ctrlInfoArray[n]->m_nMapIndex == nCurSel)
					break;
			}
			ASSERT(n < m_ctrlInfoArray.GetSize());
			GetJHHBView()->m_Spy.SetCurSel(n);
		}

		int	nIndex = 0;
		if (m_bUseDao)	// DAO
		{
			CDaoStationInfoSet*	pDaoInfoSet = m_pDaoStationInfoSet;
			ASSERT(pDaoInfoSet->GetRecordCount() != 0);
			pDaoInfoSet->MoveFirst();
			while (!pDaoInfoSet->IsEOF())
			{
				pDaoInfoSet->Edit();
				pDaoInfoSet->m_SW = m_ctrlInfoArray[nIndex ++]->m_bActive;
				pDaoInfoSet->Update();
				pDaoInfoSet->MoveNext();
			}
		}
		else	// ODBC
		{
			CStationInfoSet*	pInfoSet = m_pStationInfoSet;
			ASSERT(pInfoSet->GetRecordCount() != 0);
			pInfoSet->MoveFirst();
			while (!pInfoSet->IsEOF())
			{
				pInfoSet->Edit();
				pInfoSet->m_SW = m_ctrlInfoArray[nIndex ++]->m_bActive;
				pInfoSet->Update();
				pInfoSet->MoveNext();
			}
		}
	}
}


void CALLBACK	CJHHBDoc::TimerProc(HWND  hwnd, UINT  uMsg,
	UINT  uIDEvent, DWORD  dwTime)
{
	CJHHBDoc*	pJHHBDoc = (CJHHBDoc*)((CMainFrame*)::AfxGetApp()->m_pMainWnd)->GetActiveDocument();

	ASSERT(uIDEvent == pJHHBDoc->m_nWorkTimerID);

	int	nPendingStation = CCtrlInfoObject::m_nCurWorkStation;
	if (nPendingStation != -1)	// busy ...
	{
		CCtrlInfoObject*	pCurCtrlInfo = pJHHBDoc->m_ctrlInfoArray[nPendingStation - 1];
		switch (pCurCtrlInfo->m_status)
		{
		case CCtrlInfoObject::COMM_STATUS_IDLE:
			ASSERT(FALSE);
			break;

		case CCtrlInfoObject::COMM_STATUS_WAITREPLY:
		{
			CTimeSpan	timeSpan = CTime::GetCurrentTime() - pCurCtrlInfo->m_lastTime;
			if (timeSpan.GetTotalSeconds() > pJHHBDoc->m_nWaitReplyTimeout)
			{
				CString	strWaitTimeout;
				strWaitTimeout.Format(IDS_LOGWAITTIMEOUT, pCurCtrlInfo->GetStationName());
				pJHHBDoc->GetLogView()->AddNewLog(strWaitTimeout);

				CCtrlInfoObject::m_nCurWorkStation = -1;
				pJHHBDoc->m_bAutoActivated = FALSE;

				// Reset time, avoid dead loop for error in station or comm line
				pJHHBDoc->m_timeLast= CTime::GetCurrentTime();

				pCurCtrlInfo->m_lastTime = CTime::GetCurrentTime();
				pCurCtrlInfo->m_bCommSuccess = FALSE;
				pCurCtrlInfo->m_status = CCtrlInfoObject::COMM_STATUS_IDLE;
				// To refresh the semaphore on status_bar 
				((CMainFrame*)::AfxGetApp()->m_pMainWnd)->RefreshStatusBar();

			}
			break;
		}

		case CCtrlInfoObject::COMM_STATUS_TRANSDATA:
		{
			CTimeSpan	timeSpan = CTime::GetCurrentTime() - pCurCtrlInfo->m_lastTime;
			if (timeSpan.GetTotalSeconds() > pJHHBDoc->m_nTransDataTimeout)
			{
				CString	strSendTimeout;
				strSendTimeout.Format(IDS_LOGSENDTIMEOUT, pCurCtrlInfo->GetStationName());
				pJHHBDoc->GetLogView()->AddNewLog(strSendTimeout);

				CCtrlInfoObject::m_nCurWorkStation = -1;
				pJHHBDoc->m_bAutoActivated = FALSE;

				// Reset time, avoid dead loop for error in station or comm line
				pJHHBDoc->m_timeLast= CTime::GetCurrentTime();
				pCurCtrlInfo->m_lastTime = CTime::GetCurrentTime();
				pCurCtrlInfo->m_bCommSuccess = FALSE;
				pCurCtrlInfo->m_status = CCtrlInfoObject::COMM_STATUS_IDLE;
				// To refresh the semaphore on status_bar 
				((CMainFrame*)::AfxGetApp()->m_pMainWnd)->RefreshStatusBar();
			}  
			break;
		}

		default:
			ASSERT(FALSE);
		}
	}
	else	// idle
	{
		if (!pJHHBDoc->m_bRelayActivated)	//	可以自动转播
		{		
			CTime	timeCurrent = CTime::GetCurrentTime();
			CTimeSpan	timeSpan;
			timeSpan = timeCurrent - pJHHBDoc->m_timeLast;
			if (timeSpan.GetTotalSeconds() > 10 )	//每次请求必须间隔10秒
			{
				int n;
				for ( n = pJHHBDoc->m_nCurStation; n < pJHHBDoc->m_ctrlInfoArray.GetSize(); ++ n)//2001年6月1日改，原pJHHBDoc->m_nCurStation处为0
				{	
					CCtrlInfoObject*	pCurCtrlInfo = pJHHBDoc->m_ctrlInfoArray[n];
					if (pCurCtrlInfo->m_bActive == FALSE)
						continue;