message.cpp

基于Nuleus操作系统和s3c4510的编写的EFC。已经包含了该EFC的设计说明。这是个实际产品的代码

	BYTE uMin  = mRecv.puData[1];
	BYTE uHour = mRecv.puData[2];
	WORD wInterval;
	
	if (SUBCMD_READ)
	{
		switch (mRecv.uSubCmd & 0x07) 
		{
		case 0x00:		//	all nodes on the net
			break;
		case 0x01:		//	only one node
			mSend.SetLength(12);
			mSend.puData[0] = m_pcdDevice->GetAutoReportState();
			break;
//		case 0x02:		//	set AutoReport  path
//			arpPath = m_pcdDevice->GetAutoReportPath();
//			mSend.SetLength(14);
//			mSend.puData[0] = arpPath.uPath;
//			mSend.puData[1] = arpPath.uModule;
//			mSend.puData[2] = arpPath.uPort;
//			break;
		case 0x04:		//	set AutoReport Alarm
			mSend.SetLength(13);
			mSend.puData[0] = LOBYTE(m_pcdDevice->GetAutoReportLevel() );
			//	reserved
			mSend.puData[1] = HIBYTE(m_pcdDevice->GetAutoReportLevel() );
			break;
		case 0x05:
			mSend.SetLength(14);
			wInterval = GetAutoReportInterval();
			uHour = wInterval/3600;
			wInterval -= (uHour*3600);
			uMin = wInterval/60;
			wInterval -= (uMin*60);
			uSec = wInterval;
			mSend.puData[0] = uSec;
			mSend.puData[1] = uMin;
			mSend.puData[2] = uHour;
			break;
		default:
			mSend.SetErrorCmd(CMD_BAD_COMMAND);
			break;
		}
	}
	else
	{
		switch (mRecv.uSubCmd & 0x07) 
		{
		case 0x00:		//	all nodes on the net
			break;
		case 0x01:		//	only one node
			m_pcdDevice->SetAutoReportState(mRecv.puData[0]);
			break;
//		case 0x02:		//	set AutoReport  path
//			arpPath.uPath	= mRecv.puData[0];
//			arpPath.uModule = mRecv.puData[1];
//			arpPath.uPort	= mRecv.puData[2];
//			m_pcdDevice->SetAutoReportPath(arpPath);
//			break;
		case 0x04:		//	set AutoReport Alarm
			m_pcdDevice->SetAutoReportLevel(MAKEWORD(mRecv.puData[0],mRecv.puData[1]) );
			break;
		case 0x05:
			wInterval = uHour*3600 + uMin*60 + uSec;
			SetAutoReportInterval(wInterval);
			break;
		default:
			mSend.SetErrorCmd(CMD_BAD_COMMAND);
			break;
		}
	}	
}

// Get user board configuration
// Process command CMD_USER_CONFIG
void CMessage::OnUserConfig(SESSION &session)
{
	MESSAGE &mSend = session.mSend;
	MESSAGE &mRecv = session.mRecv;

	ASSERT(m_pcdDevice);

	if (SUBCMD_READ)
	{
		CBoard *pcbBoard = NULL;
		VERSIONINFO viInfo;
		WORD wConfig;

		viInfo.eType = VERSIONINFO::CPLD;

		mSend.SetLength(75);
		memset(mSend.puData, 0, 64);
		for (int i = 0; i < 16; i++)
		{
			if ((pcbBoard = m_pcdDevice->GetBoard(i)) != NULL)
			{
				wConfig = pcbBoard->GetConfig();
				*(mSend.puData + 4 * i + 0) = (BYTE)pcbBoard->GetType();
				*(mSend.puData + 4 * i + 1) = LOBYTE(wConfig);
				*(mSend.puData + 4 * i + 2) = HIBYTE(wConfig);

				if (!pcbBoard->GetVersionInfo(viInfo))
				{
					viInfo.eType = VERSIONINFO::FPGA;
					if (!pcbBoard->GetVersionInfo(viInfo))
						viInfo.wVersion = 0;
				}
				*(mSend.puData + 4 * i + 3) = (HIBYTE(viInfo.wVersion) << 4) | 
											   (LOBYTE(viInfo.wVersion) & 0x0F);		
			}
		}
	}
	else
	{
		mSend.SetErrorCmd(CMD_BAD_COMMAND);
	}
}

// Process command CMD_SYS_TIME
void CMessage::OnSysTime(SESSION &session)
{
	MESSAGE &mSend = session.mSend;
	MESSAGE &mRecv = session.mRecv;
	
	if (SUBCMD_WRITE) 
	{// write mode
		SetSystemTime((SYSTEMTIME*)mRecv.puData);
	}
	else
	{// read mode
		mSend.SetLength(18);
		GetSystemTime((SYSTEMTIME*)mSend.puData);
	}	
}

// Process command CMD_EVENT
void CMessage::OnEvent(SESSION &session)
{
	MESSAGE &mSend = session.mSend;
	MESSAGE &mRecv = session.mRecv;

	ASSERT(m_pceEventLog);

	const EVENT *peEvent = NULL;
	UINT i;
	BYTE uNum, uType, uStart, uStop;
	
	if (SUBCMD_READ) 
	{// read mode
		switch(mRecv.uSubCmd & 0x07)
		{
		case 0x01:// number of event
			mSend.SetLength(13);
			i = m_pceEventLog->GetCount();
			mSend.puData[0] = HIBYTE(i);
			mSend.puData[1] = LOBYTE(i);
			///////////////////////////////////////////////////////////////////
			// NOTE: temporary code. for compatibility witch low version console
			if (i > 200)
			{// max. 200 events supported.
				mSend.puData[0] = 0;
				mSend.puData[1] = 200;
			}
			///////////////////////////////////////////////////////////////////
			break;
		case 0x02:// some events in detail
			uStart = mRecv.puData[0] - 1;
			uStop  = mRecv.puData[1] + uStart;
			if (m_pceEventLog->GetCount() < uStop)
			{
				uStop = m_pceEventLog->GetCount();
			}
			uNum = (uStop > uStart) ? (uStop - uStart) : 0;
			mSend.SetLength(MESSAGE_HEADER_SIZE + uNum * sizeof(EVENT) + 2);
			mSend.puData[0] = uNum;
			for (i = uStart; i < uStop; i++)
			{
				peEvent = m_pceEventLog->GetEvent(i);
				ASSERT(peEvent);
				memcpy(mSend.puData + 1 + (i - uStart) * sizeof(EVENT), peEvent, 
					sizeof(EVENT));
			}
			break;
		case 0x03:// events with the specific type
			uType = mRecv.puData[0];
			uNum  = 0;
			for (i = 0; i < m_pceEventLog->GetCount(); i++)
			{
				peEvent = m_pceEventLog->GetEvent(i);
				ASSERT(peEvent);
				if (EventCompare(uType, peEvent->uType, peEvent->uParam[1]))
//				if (uType == peEvent->uType) 
					uNum++;
			}
			
			///////////////////////////////////////////////////////////////////
			if (uNum > 8)
			{
				uNum = 8;
			}
			///////////////////////////////////////////////////////////////////
			
			mSend.SetLength(MESSAGE_HEADER_SIZE + uNum * sizeof(EVENT) + 2);
			mSend.puData[0] = uNum;
			uNum = 0;
			for (i = 0; i < m_pceEventLog->GetCount(); i++)
			{
				peEvent = m_pceEventLog->GetEvent(i);
				ASSERT(peEvent);
				if (EventCompare(uType, peEvent->uType, peEvent->uParam[1]))
//				if (peEvent->uType == uType)
				{
					memcpy(mSend.puData + 1 + uNum * sizeof(EVENT), peEvent, sizeof(EVENT));
					if (++uNum >= mSend.puData[0])
						break;
				}
			}
			break;
		}
	}
	else
	{// write mode
		mSend.SetErrorCmd(CMD_BAD_COMMAND);
	}		
}

// Process command CMD_CLEAR
void CMessage::OnEventClear(SESSION &session)
{
	MESSAGE &mSend = session.mSend;
	MESSAGE &mRecv = session.mRecv;

	ASSERT(m_pceEventLog);

	BOOL bError = TRUE;

	if (SUBCMD_WRITE)
	{
		switch(mSend.uSubCmd & 0x07)
		{
		case 0x01:	// clear event table
			m_pceEventLog->Clear();
			bError = FALSE;
			break;
		case 0x02:	// clear minor alarm
			break;
		case 0x03:	// clear major alarm
			break;
		case 0x04:	// clear Critical(Audio)
			break;
		}
	}
	if (bError)
	{
		mSend.SetErrorCmd(CMD_BAD_COMMAND);
	}
}

// Gets the version of the Message_Format.
// Process command CMD_MSG_VERSION
void CMessage::OnMsgVersion(SESSION &session)
{
	MESSAGE &mSend = session.mSend;
	MESSAGE &mRecv = session.mRecv;

	if (SUBCMD_READ)
	{
		mSend.SetLength(13);
		mSend.puData[0] = LOBYTE(GetVersion());
		mSend.puData[1] = HIBYTE(GetVersion());
	}
	else
	{
		mSend.SetLength(CMD_BAD_COMMAND);
	}
}

// Gets the version of software(APP,EFC,protocol)
// Process command CMD_VERSION
void CMessage::OnSoftWareVersion(SESSION &session)
{
	MESSAGE &mSend = session.mSend;
	MESSAGE &mRecv = session.mRecv;

	BYTE uModule = mRecv.puData[0];
	DWORD dwVer_Num = 0;
	if (SUBCMD_READ)
	{
		switch (uModule)
		{
		case 0xFF:				//	MCU
			mSend.SetLength(56);
			memset(mSend.puData,0xFF,45);
			mSend.puData[0] = 1;	// APP on system Board
			dwVer_Num = MAKELONG( 0, GetApp()->GetVersion() );
			memcpy(&mSend.puData[1], (BYTE*)&dwVer_Num, 4);
			mSend.puData[5] = 0;	// EFC on system Board	
			dwVer_Num = MAKELONG( GetEfcBuildNum(), GetEfcVersion() );
			memcpy(&mSend.puData[6], (BYTE*)&dwVer_Num, 4);		
			break;
		default:
			mSend.SetErrorCmd(CMD_BAD_COMMAND);
			break;
		}
	}
	else
	{
		mSend.SetErrorCmd(CMD_BAD_COMMAND);
	}
}


// Read or write the name and node id (device address) of the device
// Process command CMD_HOST
void CMessage::OnHost(SESSION &session)
{
	MESSAGE &mSend = session.mSend;
	MESSAGE &mRecv = session.mRecv;

	ASSERT(m_pcdDevice);

	DEVICEINFO diInfo;
	m_pcdDevice->GetDeviceInfo(diInfo);
	if (SUBCMD_READ) 
	{
		mSend.SetLength(23);
		memcpy(mSend.puData, diInfo.strName, 8);
		mSend.puData[8]  = '\0';
		mSend.puData[9]  = diInfo.aAddr.uAddrH;
		mSend.puData[10] = diInfo.aAddr.uAddrL;
		mSend.puData[11] = diInfo.aAddr.uGroup;
	}
	else
	{
		diInfo.strName = mRecv.puData;
		diInfo.aAddr.uAddrH = mRecv.puData[9];
		diInfo.aAddr.uAddrL = mRecv.puData[10];
		diInfo.aAddr.uGroup = mRecv.puData[11];
		m_pcdDevice->SetDeviceInfo(diInfo);
	}
}

// Login time-out value
// Process command CMD_LOGTIME
void CMessage::OnLogTime(SESSION &session)
{
	MESSAGE &mSend = session.mSend;
	MESSAGE &mRecv = session.mRecv;

	if (SUBCMD_READ) 
	{
		mSend.SetLength(12);
		*mSend.puData = (BYTE)(SESSION::nTimeout / 60);
	}
	else
	{
		SESSION::nTimeout = *mRecv.puData * 60;	// convert to seconds
//		GetApp()->SetModifiedFlag();
	}
}

// Loopback time-out value
// Process command CMD_LOOPBACK_TIME
void CMessage::OnLoopbackTime(SESSION &session)
{
	MESSAGE &mSend = session.mSend;
	MESSAGE &mRecv = session.mRecv;

	ASSERT(m_pcdDevice);
	if (SUBCMD_READ) 
	{
		mSend.SetLength(12);
		*mSend.puData = (BYTE)(m_pcdDevice->GetLoopbackTime() / 60);
	}
	else
	{
		m_pcdDevice->SetLoopbackTime(*mRecv.puData * 60);	// convert to seconds
	}
}

// Read & write external memory
// Process command CMD_X
void CMessage::OnX(SESSION &session)
{
	MESSAGE &mSend = session.mSend;
	MESSAGE &mRecv = session.mRecv;
	
	BYTE uCount = mRecv.puData[4];
	VBYTE *pvbBase = (VBYTE*)MAKELONG(MAKEWORD(mRecv.puData[3], mRecv.puData[2]),
		MAKEWORD(mRecv.puData[1], mRecv.puData[0]));

	if (SUBCMD_READ) 
	{
		mSend.SetLength(11 + uCount);
		BYTE *puDest = mSend.puData;
		// here, I do not use the memcpy function, because some device can only
		//   be accessed with 8-bit(byte) width.
		for (; uCount > 0; uCount--)
		{
			*puDest++ = *pvbBase++;
		}
	}
	else
	{
		BYTE uValue = mRecv.puData[5];

		ASSERT(m_pcdDevice);
		CFlash *pcFlash = m_pcdDevice->GetFlash();
		ASSERT(pcFlash);

		DWORD dwMinAddr = pcFlash->GetBaseAddr();
		DWORD dwMaxAddr = pcFlash->GetFlashSize() + dwMinAddr - 1;

		///////////////////////////////////////////////////////////////////////
		// Debug command
		if ((DWORD)pvbBase == 0x12345678)
		{// erase flash sector
			for (; uCount > 0; uCount--)
			{
				VERIFY(pcFlash->EraseSector(uValue));
				uValue++;
			}
			return;
		}
		///////////////////////////////////////////////////////////////////////
		
		// here, I do not use the memset function, because some device can only
		//   be accessed with 8-bit(byte) width.
		for (; uCount > 0; uCount--)
		{
			if (dwMinAddr <= (DWORD)pvbBase && (DWORD)pvbBase <= dwMaxAddr)
			{// write to flash
				VERIFY(pcFlash->Write((DWORD)pvbBase, &uValue, 1));
			}
			else
			{
				*pvbBase = uValue;
			}
			ASSERT(*pvbBase == uValue);
			pvbBase++;
		}
	}
}

// Set Master station
// Process command CMD_MASTER_STATION
void CMessage::OnMaster(SESSION &session)
{
	MESSAGE &mSend = session.mSend;
	MESSAGE &mRecv = session.mRecv;

	ASSERT(m_pcdDevice);
	ADDR addrMaster;
	if (SUBCMD_READ)
	{
		switch (mRecv.uSubCmd & 0x07) 
		{
		case 0x01:
			addrMaster = m_pcdDevice->GetMasterStation();
			mSend.SetLength(23);
			mSend.puData[9] = addrMaster.uAddrH;
			mSend.puData[10] = addrMaster.uAddrL;
			mSend.puData[11] = addrMaster.uGroup;
			break;
		default:
			mSend.SetErrorCmd(CMD_BAD_COMMAND);
			break;
		}
	}
	else
	{
		switch (mRecv.uSubCmd & 0x07) 
		{
		case 0x01:
			addrMaster.uAddrH = mRecv.puData[0];
			addrMaster.uAddrL = mRecv.puData[1];
			addrMaster.uGroup = mRecv.puData[2];
			m_pcdDevice->SetMasterStation(addrMaster);
			break;
		default:
			mSend.SetErrorCmd(CMD_BAD_COMMAND);
			break;
		}
	}	
}

// Change password and user name
// Process command CMD_PASSWORD
void CMessage::OnPassword(SESSION &session)
{
	MESSAGE &mSend = session.mSend;
	MESSAGE &mRecv = session.mRecv;

	if (SUBCMD_WRITE) 
	{
		ASSERT(m_pcuUser);
		
		USER usUser;
		usUser.strUser = session.strUser;
		usUser.uLevel = session.uLevel;
		m_pcuUser->Remove(usUser.strUser);
		BOOL bIgoreName = (mRecv.uSubCmd & 0x03) == 1;
		if (!bIgoreName) 
			usUser.strUser = mRecv.puData;
		usUser.strPswd = &mRecv.puData[9];
		m_pcuUser->AddUser(usUser);
	}