⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 message.cpp

📁 基于Nuleus操作系统和s3c4510的编写的EFC。已经包含了该EFC的设计说明。这是个实际产品的代码
💻 CPP
📖 第 1 页 / 共 5 页
字号:
🔍
12345 
			mSend.puData[4 + i] = ndDevice.auSubnet[i];
			mSend.puData[8 + i] = ndDevice.auGateway[i];
		}
		mSend.puData[12] = HIBYTE(ndDevice.nPort);
		mSend.puData[13] = LOBYTE(ndDevice.nPort);
	}
}

// command for testing communication state
// Process command CMD_TEST
void CMessage::OnTest(SESSION &session)
{
	MESSAGE &mRecv = session.mRecv;
	MESSAGE &mSend = session.mSend;

	if (SUBCMD_READ)
	{
		WORD wLength = MAKEWORD(mRecv.uLength, 0);
		mSend.SetLength(wLength);
		memcpy(mSend.puData, mRecv.puData, mRecv.GetDataLength());
	}
	else
	{
		mSend.SetErrorCmd(CMD_BAD_COMMAND);
	}
}

// Load default
// Process command CMD_LOADDEF
void CMessage::OnLoadDef(SESSION &session)
{
	MESSAGE &mRecv = session.mRecv;
	MESSAGE &mSend = session.mSend;

	if (SUBCMD_WRITE) 
	{
		CMemFile file;
		LPCSTR lpszBase = NULL, lpszDerived = NULL;
		switch (mRecv.uSubCmd & 0x07)
		{
		case 0x01: // MCK
			break;
		case 0x02: //
			break;
		case 0x03: //
			break;
		case 0x04: //
			break;
		case 0x07: // All boards
			lpszBase = GetApp()->CRTApp::GetDefaultConfig();
			lpszDerived = GetApp()->GetDefaultConfig();
			file.WriteLine(lpszBase);
			if (lpszDerived != lpszBase)
			{
				file.WriteLine(lpszDerived);
			}
			file.SeekToBegin();
			GetApp()->DeleteProfileSection(NULL);
			GetApp()->LoadFromFile(file);
			file.Close();
			m_pcdDevice->SetFlagLoaddef(mRecv.uPacket);
			GetApp()->SetModifiedFlag();
			break;
		default:
			break;
		}
	}
	else
	{
		mSend.SetErrorCmd(CMD_BAD_COMMAND);
	}
}

// Sets/Gets LIU sync mode
// Process command CMD_LIUSYNCMODE
void CMessage::OnLiuSyncMode(SESSION &session)
{
	MESSAGE &mRecv = session.mRecv;
	MESSAGE &mSend = session.mSend;

	ASSERT(m_pcdDevice);
	CBoard *pcbBoard = NULL;
	BYTE uBoard = mRecv.puData[0];
	pcbBoard = m_pcdDevice->GetBoard(uBoard);
	if (SUBCMD_READ) 
	{
		mSend.SetLength(13);
		mSend.puData[0] = uBoard;
		if (pcbBoard != NULL) 
		{
			mSend.puData[1] = LOBYTE(pcbBoard->GetSynMode());
		}
	}
	else
	{
		if (pcbBoard != NULL) 
		{
			pcbBoard->SetSynMode(mRecv.puData[1]);
		}
	}
}

// Sets/Gets loopback mode
// Process command CMD_LOOPBACK
void CMessage::OnLoopback(SESSION &session)
{
	MESSAGE &mRecv = session.mRecv;
	MESSAGE &mSend = session.mSend;

	ASSERT(m_pcdDevice);

	CInterface *pciInterface = NULL;
	BYTE uBoard = mRecv.puData[0];		// Zero-based board index
	WORD wType = mRecv.puData[1];		// interface type
	BYTE uInterface = mRecv.puData[2];	// Zero-based interface index
	pciInterface = m_pcdDevice->GetInterface(uBoard, wType, uInterface);

	if (SUBCMD_READ) 
	{
		mSend.SetLength(13);
		if (pciInterface != NULL) 
		{
			mSend.puData[0] = 0x00;
			switch (pciInterface->GetLoopbackMode())
			{
			case LOOPBACK_OFF:
				mSend.puData[1] = 0x00;
				break;
			case LOOPBACK_MODE_LOCAL:
				mSend.puData[1] = 0x01;
				break;
			case LOOPBACK_MODE_REMOTE:
				mSend.puData[1] = 0x02;
				break;
			case LOOPBACK_MODE_ANALOG:
				mSend.puData[1] = 0x03;
				break;
			default:
				mSend.puData[1] = pciInterface->GetLoopbackMode();
				break;
			}
		}
		else
		{
			mSend.puData[0] = 0x01;	// invalid interface
		}
	}
	else
	{
		int nMode;
		mSend.SetLength(12);
		mSend.puData[0] = 0x00;
		switch(mRecv.puData[3]) 
		{
		case 0x00:
			nMode = LOOPBACK_OFF;
			break;
		case 0x01:
			nMode = LOOPBACK_MODE_LOCAL;
			break;
		case 0x02:
			nMode = LOOPBACK_MODE_REMOTE;
			break;
		case 0x03:
			nMode = LOOPBACK_MODE_ANALOG;
			break;
		default:
			mSend.puData[0] = 0x02; // invalid loop back mode
			break;
		}
		if (pciInterface != NULL) 
		{
			pciInterface->SetLoopbackMode(nMode);
		}
		else
		{
			mSend.puData[0] = 0x01; // invalid interface
		}
	}
}

// LIU PCM & CRC setting
// process command CMD_PCMCRC
void CMessage::OnPcmCrc(SESSION &session)
{
	MESSAGE &mRecv = session.mRecv;
	MESSAGE &mSend = session.mSend;

	ASSERT(m_pcdDevice);
	CBoard *pcbBoard = NULL;
	CLiuInterface *pciLiu = NULL;
	BYTE uBoard = mRecv.puData[0];
	CLiuInterface::UConfig conConfig;
	int i;

	if (SUBCMD_WRITE)
	{
		if ((pcbBoard = m_pcdDevice->GetBoard(uBoard)) != NULL)
		{
			for (i = 0; i < 8; i++)
			{
				if (GetBitVal(mRecv.puData[1], i)) // Port flag
				{
					pciLiu = (CLiuInterface*)
						pcbBoard->GetInterface(INTERFACE_TYPE_LIU, i);
					if (pciLiu != NULL)
					{
						conConfig.dwAll = pciLiu->GetConfig();
						conConfig.bits.PCM = GetBitVal(mRecv.puData[2], i); // PCM
						conConfig.bits.CRC = GetBitVal(mRecv.puData[3], i); // CRC
						pciLiu->SetConfig(conConfig.dwAll);
					}
				}
			}
		}
	}
	else
	{ // Read mode
		mSend.SetLength(13);
		if ((pcbBoard = m_pcdDevice->GetBoard(uBoard)) != NULL)
		{
			for (i = 0; i < 8; i++)
			{
				pciLiu = (CLiuInterface*)
					pcbBoard->GetInterface(INTERFACE_TYPE_LIU, i);
				if (pciLiu != NULL)
				{
					conConfig.dwAll = pciLiu->GetConfig();
					SetBitVal(mSend.puData[0], i, conConfig.bits.PCM);
					SetBitVal(mSend.puData[1], i, conConfig.bits.CRC);
				}
			}
		}
	}
}

// Alarm setting
// process command CMD_ALARM
void CMessage::OnAlarm(SESSION &session)
{
	MESSAGE &mRecv = session.mRecv;
	MESSAGE &mSend = session.mSend;
	
	ASSERT(m_pcdDevice);
	BYTE uBoard = mRecv.puData[0];
	CBoard *pcbBoard = NULL;
	CLiuInterface *pciLiu = NULL;
	DWORD dwSetting;
	BYTE uPortFlag;
	UINT i, j, k;
	
	if (SUBCMD_WRITE) 
	{
		switch(mRecv.uSubCmd & 3)
		{
		case 0x01: // LIU alarm setting
			uPortFlag = mRecv.puData[1];
			// 0xFF: config all boards
			k = (uBoard == 0xFF) ? 0 : uBoard;
			for (; k < BOARDCOUNT_MAX; k++)
			{
				if ((pcbBoard = m_pcdDevice->GetBoard(k)) != NULL) 
				{
					for (i = 0; i < LIUPORTCOUNT_MAX; i++)
					{
						if (GetBitVal(uPortFlag, i))
						{
							pciLiu = (CLiuInterface*)
								pcbBoard->GetInterface(INTERFACE_TYPE_LIU, i);
							ASSERT(IsKindOf(RUNTIME_CLASS(CAsyInterface)));
							if (pciLiu != NULL)
							{
								dwSetting = pciLiu->GetAlarmSetting();
								for (j = 0; j < 8; j++)
								{
									if (GetBitVal(mRecv.puData[4 * i + 2], j))
									{
										SetBitVal(dwSetting, j, 
											GetBitVal(mRecv.puData[4 * i + 4], j));
									}
								}
								pciLiu->SetAlarmSetting(dwSetting);
							}
						}
					}
				}
				if (uBoard != 0xFF)
					break;
			}
			break;
		}
	}
	else
	{
		switch(mRecv.uSubCmd & 0x03)
		{
		case 0x01: // LIU alarm setting
			mSend.SetLength(28);
			mSend.puData[0] = 0;
			if ((pcbBoard = m_pcdDevice->GetBoard(uBoard)) != NULL) 
			{
				for (i = 0; i < pcbBoard->GetInterfaceCount(INTERFACE_TYPE_LIU)
					&& i < LIUPORTCOUNT_MAX; i++)
				{
					SetBitVal(mSend.puData[0], i, 1); // Active flag
					pciLiu = (CLiuInterface*)
						pcbBoard->GetInterface(INTERFACE_TYPE_LIU, i);
					if (pciLiu != NULL) 
					{
						mSend.puData[i * 2 + 1] = LOBYTE(pciLiu->GetAlarmSetting());
						mSend.puData[i * 2 + 2] = HIBYTE(pciLiu->GetAlarmSetting());
					}
				}
			}
			break;
		}
	}
}

// Read & write the seconds of interval which minor alarm upgrades to major alarm
// Process command CMD_MINOR_UPGRADE
void CMessage::OnMinorUpgrade(SESSION &session)
{
	MESSAGE &mRecv = session.mRecv;
	MESSAGE &mSend = session.mSend;

	ASSERT(m_pcdDevice);
	if (SUBCMD_READ) 
	{
		mSend.SetLength(12);
		mSend.puData[0] = (BYTE)m_pcdDevice->GetMinorUpgrade();
	}
	else
	{
		m_pcdDevice->SetMinorUpgrade(mRecv.puData[0]);
	}
}

// Read & write the major and minor alarm
// Process command CMD_MAJOR_MINOR
void CMessage::OnMajorMinor(SESSION &session)
{
	MESSAGE &mRecv = session.mRecv;
	MESSAGE &mSend = session.mSend;

	ASSERT(m_pcdDevice);
	if (SUBCMD_READ) 
	{
		mSend.SetLength(13);
		mSend.puData[0] = LOBYTE(m_pcdDevice->GetAlarmLevel());
		mSend.puData[1] = HIBYTE(m_pcdDevice->GetAlarmLevel());
	}
	else
	{
		m_pcdDevice->SetAlarmLevel(MAKEWORD(mRecv.puData[0], mRecv.puData[1]));
	}
}

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

	if (SUBCMD_WRITE)
	{
		ASSERT(m_pcdDevice);
		mSend.SetLength(15);
		mSend.aDesAddr = mSend.aSrcAddr;
		memcpy(mSend.puData, &mSend.aSrcAddr, sizeof(ADDR));
		mSend.puData[3] = m_pcdDevice->GetProductID();
	}
	else
	{
		mSend.SetErrorCmd(CMD_BAD_COMMAND);
	}
}

// Login to device
// Process command CMD_LOGIN 
void CMessage::OnLogin(SESSION &session)
{
	MESSAGE &mRecv = session.mRecv;
	MESSAGE &mSend = session.mSend;

	ASSERT(m_pcuUser);
	ASSERT(m_pcdDevice);

	if (SUBCMD_WRITE)
	{
		CString strUser = (LPCSTR)mRecv.puData;
		CString strPswd = (LPCSTR)(mRecv.puData + 9);
		DEVICEINFO diInfo;
		USER usUser;

		session.bLogin = FALSE;
		if (m_pcuUser->Find(strUser, usUser) && usUser.strPswd == strPswd)
		{
			session.bLogin = TRUE;
			m_pcdDevice->GetDeviceInfo(diInfo);
			mSend.aSrcAddr = diInfo.aAddr;
			
			mSend.SetLength(43);
			// login info
			mSend.puData[0] = usUser.uLevel;
			// host name
			memcpy(mSend.puData + 1, diInfo.strName, 8);
			mSend.puData[9] = '\0';
			// device address, group
			memcpy(mSend.puData + 10, &diInfo.aAddr, sizeof(ADDR));
			// device type
			*(mSend.puData + 13) = m_pcdDevice->GetProductID();

			session.strUser = usUser.strUser;
			session.uLevel  = usUser.uLevel;
			if (mRecv.uPacket >= UART_USER && mRecv.uPacket <= NET_USER_MAX)
			{
				memcpy(m_muUsers[mRecv.uPacket].uUserName, mRecv.puData, 9);
				m_muUsers[mRecv.uPacket].uUserLevel = usUser.uLevel;
			}
		}
	}
	else
		mSend.SetErrorCmd(CMD_BAD_COMMAND);

	if (!session.bLogin)
	{
		mSend.SetErrorCmd(CMD_ACCESS_DENIED);
	}
}

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

	if (SUBCMD_WRITE)
	{
		session.bLogin = FALSE;
		session.uLevel = ACCESS_LEVEL_DENIED;
		session.strUser.Empty();		
	}
	else
	{
		mSend.SetErrorCmd(CMD_BAD_COMMAND);
	}
}

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

	if (SUBCMD_READ)
	{
		mSend.SetLength(75);
		memset(mSend.puData, 0, 64);
		WORD wVer = GetApp()->GetVersion();
		// APP VERSION
		mSend.puData[0] = (HIBYTE(wVer) << 4) | (LOBYTE(wVer) >> 4);
		// BIOS VERSION
		mSend.puData[2] = VPbyte(0x010000B0);
	}
	else
	{
		mSend.SetErrorCmd(CMD_BAD_COMMAND);
	}
}

// Save data to flash
// Process command CMD_SAVE
void CMessage::OnSaveFlash(SESSION &session)
{
	MESSAGE &mSend = session.mSend;
	MESSAGE &mRecv = session.mRecv;

	if (SUBCMD_READ)
	{
		switch (mRecv.uSubCmd & 0x07) 
		{
		case 0x04:
			m_pcdDevice->SetFlagLoaddef(mRecv.uPacket);
			GetApp()->SetModifiedFlag();
			break;
		default:
			mSend.SetErrorCmd(CMD_BAD_COMMAND);
			break;
		}
	}
	else
	{
		mSend.SetErrorCmd(CMD_BAD_COMMAND);
	}
}

// Auto report config
// Process command CMD_AUTOREPORT
void CMessage::OnAutoReportConfig(SESSION &session)
{
	MESSAGE &mSend = session.mSend;
	MESSAGE &mRecv = session.mRecv;

	ASSERT(m_pcdDevice);
//	AUTORE_PATH arpPath;
	BYTE uSec  = mRecv.puData[0];
12345

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -