103.cpp

规约转换 103.104 规约转换 适用于电力系统

				}
#endif

				CEquipment* pEquipment = GetEquipmentByOrder( pProtParam->btRTU );
				if ( !pEquipment )
#ifndef _103_LOG
					break;
#else
				{
					CTime tmNow = CTime::GetCurrentTime();

					CString szInfo = tmNow.Format( "%Y-%m-%d %H:%M:%S" );
					szInfo += "召唤保护定值(压板)\n\t参数为\n\t";

					char szTemp[128];
					sprintf( szTemp, "\t%d,%d,%d,%d,%d,%d,%d,%08x,%08x\n", 
						pProtParam->btRTU, pProtParam->btCom, pProtParam->btAddr, pProtParam->btCPU,
						pProtParam->btArea, pProtParam->btValType, pProtParam->btCount, pProtParam->hWnd,
						pProtParam->lpValue );

					szInfo += szTemp;
					szInfo += "\t无此装置\n";

					::Trace103Log( szInfo );

					break;
				}
#endif
				if ( PREM_ASKYB == pProtParam->btValType )
					nRet = pEquipment->RequestYb( pProtParam->btRTU, pProtParam->hWnd, pProtParam->btCom );
				else
					nRet = pEquipment->RequestVal( pProtParam->btRTU, pProtParam->hWnd, pProtParam->btCom );

#ifndef _103_LOG
#else
				if ( PREM_OK != nRet )
				{
					CTime tmNow = CTime::GetCurrentTime();

					CString szInfo = tmNow.Format( "%Y-%m-%d %H:%M:%S" );
					szInfo += "召唤保护定值(压板):\n\t参数为\n\t";

					char szTemp[128];
					sprintf( szTemp, "\tRTU:%d,Com:%d,Addr:%d,CPU:%d\n\t\tArea:%d,ValType:%d,Count:%d,hWnd:%08x,lpValue:%08x\n", 
						pProtParam->btRTU, pProtParam->btCom, pProtParam->btAddr, pProtParam->btCPU,
						pProtParam->btArea, pProtParam->btValType, pProtParam->btCount, pProtParam->hWnd,
						pProtParam->lpValue );
					szInfo += szTemp;
					
					szInfo += "\t装置状态为\n\t";
					sprintf( szTemp, "\tState:%d,AddrLgc:%d,Counter:%d,Comm:%d, Answer:%d,Channel:%08x\r\n", 
						pEquipment->m_nState, pEquipment->m_LogicAddr.m_btAddrLgc, pEquipment->m_uTaskTimeCounter,
						pEquipment->m_bComm, pEquipment->m_pChannel );
					szInfo += szTemp;

					if ( pEquipment->m_pChannel )
					{
						szInfo += "\t通讯状态为\n\t";
						szInfo += "\t";
						szInfo += pEquipment->m_pChannel->m_szIP;

						sprintf( szTemp, ":%d\n", pEquipment->m_pChannel->m_socket );
						szInfo += szTemp;
					}

					szInfo += "\t命令执行失败\n";

					::Trace103Log( szInfo );
				}
#endif
			}
			break;

		case PREM_CHANGEPROTECTVALUE:
			{
				nRet = PREM_ERR_PARAM;

				// if the download is forbiden
				if ( !m_bProtectValue )
					break;

				PROTECTPARAM *pProtParam = (PROTECTPARAM*)wParam;
				if ( !pProtParam )
					break;

				CEquipment* pEquipment = GetEquipmentByOrder( pProtParam->btRTU );
				if ( !pEquipment )
					break;

				if ( PREM_ASKYB == pProtParam->btValType )
					nRet = pEquipment->ChangeYb( pProtParam->btRTU, pProtParam->hWnd, (BYTE*)pProtParam->lpValue, STATE_CHANGEYB );
				else
					nRet = pEquipment->ChangeVal( pProtParam->btRTU, pProtParam->hWnd, (BYTE*)pProtParam->lpValue, STATE_CHANGEVAL );
			}
			break;

		case PREM_ACKCHANGEPROTECTVALUE:
			{
				nRet = PREM_ERR_PARAM;
				
				PROTECTPARAM *pProtParam = (PROTECTPARAM*)wParam;
				if ( !pProtParam )
					break;

				CEquipment* pEquipment = GetEquipmentByOrder( pProtParam->btRTU );
				if ( !pEquipment )
					break;

				if ( PREM_ASKYB == pProtParam->btValType )
					nRet = pEquipment->ChangeYb( pProtParam->btRTU, pProtParam->hWnd, (BYTE*)pProtParam->lpValue, STATE_ACKCHANGEYB );
				else
					nRet = pEquipment->ChangeVal( pProtParam->btRTU, pProtParam->hWnd, (BYTE*)pProtParam->lpValue, STATE_ACKCHANGEVAL );
			}
			break;

		case PREM_CANCELCHANGEPROTECTVALUE:
			{
				nRet = PREM_ERR_PARAM;
				
				PROTECTPARAM *pProtParam = (PROTECTPARAM*)wParam;
				if ( !pProtParam )
					break;

				CEquipment* pEquipment = GetEquipmentByOrder( pProtParam->btRTU );
				if ( !pEquipment )
					break;

				if ( PREM_ASKYB == pProtParam->btValType )
					nRet = pEquipment->ChangeYb( pProtParam->btRTU, pProtParam->hWnd, (BYTE*)pProtParam->lpValue, STATE_CANCELCHANGEYB );
				else
					nRet = pEquipment->ChangeVal( pProtParam->btRTU, pProtParam->hWnd, (BYTE*)pProtParam->lpValue, STATE_CANCELCHANGEVAL );
			}
			break;

		case PREM_PROTECTSIGNALRESET:
			{
				// clear the fault signal
				OnFaultSignal( FALSE );

				nRet = PREM_ERR_PARAM;
				
				PROTECTPARAM *pProtParam = (PROTECTPARAM*)wParam;
				if ( !pProtParam )
					break;

				CEquipment* pEquipment = GetEquipmentByOrder( pProtParam->btRTU );
				if ( !pEquipment )
					break;

				nRet = pEquipment->RequestRst( pProtParam->btRTU, pProtParam->hWnd );
			}
			break;

		case PREM_ASKANALOGUE:
			{
				nRet = PREM_ERR_PARAM;
				
				PROTECTPARAM *pProtParam = (PROTECTPARAM*)wParam;
				if ( !pProtParam )
					break;

				CEquipment* pEquipment = GetEquipmentByOrder( pProtParam->btRTU );
				if ( !pEquipment )
					break;

				nRet = pEquipment->RequestProtAna( pProtParam->btRTU, pProtParam->hWnd, pProtParam->btCom );
			}
			break;
//
//		case PREM_ASKDIGITAL:
//			nRet = pProtectDev->AskDigital( pProtParam->hWnd );
//			break;
//
		case PREM_ASKAREA:
			{
				nRet = PREM_ERR_PARAM;
				
				PROTECTPARAM *pProtParam = (PROTECTPARAM*)wParam;
				if ( !pProtParam )
					break;

				CEquipment* pEquipment = GetEquipmentByOrder( pProtParam->btRTU );
				if ( !pEquipment )
					break;

				nRet = pEquipment->RequestArea( pProtParam->btRTU, pProtParam->hWnd, pProtParam->btValType );
			}
			break;

		case PREM_CHANGEAREA:
			{
				nRet = PREM_ERR_PARAM;
				
				// if the download is forbiden
				if ( !m_bProtectValue )
					break;

				PROTECTPARAM *pProtParam = (PROTECTPARAM*)wParam;
				if ( !pProtParam )
					break;

				CEquipment* pEquipment = GetEquipmentByOrder( pProtParam->btRTU );
				if ( !pEquipment )
					break;

				nRet = pEquipment->ChangeArea( pProtParam->btRTU, pProtParam->hWnd, pProtParam->btValType, pProtParam->btArea, STATE_CHANGEAREA );
			}
			break;

		case PREM_ACKCHANGEAREA:
			{
				nRet = PREM_ERR_PARAM;
				
				PROTECTPARAM *pProtParam = (PROTECTPARAM*)wParam;
				if ( !pProtParam )
					break;

				CEquipment* pEquipment = GetEquipmentByOrder( pProtParam->btRTU );
				if ( !pEquipment )
					break;

				nRet = pEquipment->ChangeArea( pProtParam->btRTU, pProtParam->hWnd, pProtParam->btValType, pProtParam->btArea, STATE_ACKCHANGEAREA );
			}
			break;

		case PREM_CANCELCHANGEAREA:
			{
				nRet = PREM_ERR_PARAM;
				
				PROTECTPARAM *pProtParam = (PROTECTPARAM*)wParam;
				if ( !pProtParam )
					break;

				CEquipment* pEquipment = GetEquipmentByOrder( pProtParam->btRTU );
				if ( !pEquipment )
					break;

				nRet = pEquipment->ChangeArea( pProtParam->btRTU, pProtParam->hWnd, pProtParam->btValType, pProtParam->btArea, STATE_CANCELCHANGEAREA );
			}
			break;

		case PREM_CHECKTIME:
			{
				nRet = PREM_ERR_PARAM;
				
				PROTECTPARAM *pProtParam = (PROTECTPARAM*)wParam;
				if ( !pProtParam )
					break;

				CEquipment* pEquipment = GetEquipmentByOrder( pProtParam->btRTU );
				if ( !pEquipment )
					break;

				nRet = pEquipment->TimeSync();
			}
			break;
//
//		case PREM_ASKCHKREPORT:
//			nRet = pProtectDev->AskChkReport( pProtParam->hWnd, pProtParam->btArea );
//			break;
//
		case PREM_ASKACCIDENT:
			{
				nRet = PREM_ERR_PARAM;
				
				PROTECTPARAM *pProtParam = (PROTECTPARAM*)wParam;
				if ( !pProtParam )
					break;

				CEquipment* pEquipment = GetEquipmentByOrder( pProtParam->btRTU );
				if ( !pEquipment )
					break;

				nRet = pEquipment->RequestAcc( pProtParam->btRTU, pProtParam->hWnd, pProtParam->btCom, *(WORD*)pProtParam->lpValue, pProtParam->btCount );
			}
			break;

		default:
			return PREM_ERR_MSG;
	}

	return nRet;
}

void C103App::AdjustLocalTime( SYSTEMTIME* pLocalTime )
{
	OSVERSIONINFO OsVersionInfo;

	OsVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
	::GetVersionEx( &OsVersionInfo );

	if ( VER_PLATFORM_WIN32_NT == OsVersionInfo.dwPlatformId )
	{
		HANDLE hToken;
		::OpenThreadToken( AfxGetThread()->m_hThread, TOKEN_ADJUST_PRIVILEGES, true ,&hToken );
		
		LUID uid;
		::LookupPrivilegeValue( NULL, SE_SYSTEMTIME_NAME, &uid );

		TOKEN_PRIVILEGES tp;
		tp.PrivilegeCount = 1;
		tp.Privileges[0].Luid = uid;
		tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

		::AdjustTokenPrivileges( hToken, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), (PTOKEN_PRIVILEGES)NULL, (PDWORD)NULL );

		::SetLocalTime( pLocalTime );

		tp.PrivilegeCount = 1;
		tp.Privileges[0].Luid = uid;
		tp.Privileges[0].Attributes = 0;

		::AdjustTokenPrivileges( hToken, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), (PTOKEN_PRIVILEGES)NULL, (PDWORD)NULL );
	}
	else
		::SetLocalTime( pLocalTime );
}

void C103App::ProcessBroadcastData( CString szAddr )
{
	while( 1 )
	{
		// if receive a broadcast data from device
		UINT uLength = ::NSSock_GetReceiveDataLength( m_BroadcastSocket );
		if ( uLength < BROADCASTDATALEN )
			break;

		// if receive self broadcasting message
		char szData[BROADCASTDATALEN];
		if ( szAddr == ::GetLocalAddr() )
		{
			::NSSock_GetData( m_BroadcastSocket, szData, BROADCASTDATALEN );
			break;
		}

		// read from driver
		::NSSock_GetData( m_BroadcastSocket, szData, BROADCASTDATALEN );

		// psx is running, record down
		if ( 1 == szData[0] )
		{
			m_btType = (BYTE)-1;

			// sync. host time with psx
			SYSTEMTIME SystemTime;

			// milliseconds
			SystemTime.wMilliseconds = *(WORD*)( szData + 2 ) % 1000;
			SystemTime.wSecond = *(WORD*)( szData + 2 ) / 1000;

			// minute
			SystemTime.wMinute = szData[2 + sizeof(WORD)];

			// hour
			SystemTime.wHour = szData[3 + sizeof(WORD)];

			// day of week, monday = 1, ..., sunday = 7
			SystemTime.wDayOfWeek = szData[4 + sizeof(WORD)] >> 5;
			if ( 7 == SystemTime.wDayOfWeek )
				SystemTime.wDayOfWeek = 0;

			// day of month
			SystemTime.wDay = szData[4 + sizeof(WORD)] & 0x1F;

			// month
			SystemTime.wMonth = szData[5 + sizeof(WORD)];

			// year
			SystemTime.wYear = szData[6 + sizeof(WORD)];
			if ( SystemTime.wYear < 70 )
				SystemTime.wYear += 2000;
			else
				SystemTime.wYear += 1900;

			AdjustLocalTime( &SystemTime );
		}
	}
}

#define WM_COMMESSAGE	( WM_USER + 4 )

void C103App::NotifyMainframe( int nType, CString szIP, UINT uPort )
{
	CWnd* pWnd = AfxGetMainWnd();
	if ( pWnd && pWnd->GetSafeHwnd() != NULL )
	{
		COMMSTATE CommState;
		memset( &CommState, 0, sizeof(COMMSTATE) );
		
		strncpy( CommState.szComm, szIP, MAXCOMMLEN - 1 );
		CommState.uPort = uPort;

		if ( M_SEND == nType )
			pWnd->SendMessage( WM_COMMESSAGE, COMMWM_SEND, (LPARAM)&CommState );
		else if ( M_RECEIVE == nType )
			pWnd->SendMessage( WM_COMMESSAGE, COMMWM_RECV, (LPARAM)&CommState );
	}
}

void C103App::OnFaultSignal( BOOL bFault )
{
	char szData[5 + sizeof(WORD) + sizeof(BYTE)], *pRaw = szData;
	
	*(WORD*)pRaw = m_wRtuSignal;
	pRaw += sizeof(WORD);

	*pRaw = DIGIT_RAW_DATA;
	pRaw++;

	*(WORD*)pRaw = sizeof(WORD) + sizeof(BYTE);
	pRaw += sizeof(WORD);

	*(WORD*)pRaw = (WORD)m_wIndexSignal - 1;
	pRaw += sizeof(WORD);

	if ( bFault )
		*(BYTE*)pRaw = 1;
	else
		*(BYTE*)pRaw = 0;
	
	::WriteRdbData( szData );
}

void C103App::NSSockCallBack( UINT uMsg, const char FAR* addr, PORT port, SOCKET socket )
{
	CChannel* pChannel = GetChannel( socket );

	switch ( uMsg )
	{
		case NSSOCK_DATA:
			// if broadcast message received
			if ( socket == m_BroadcastSocket )
				ProcessBroadcastData( addr );
			else
			{
				// if data received
				if ( pChannel )
				{
					while ( pChannel->ProcessReceive() );
					
					// notify mainframe
					NotifyMainframe( M_RECEIVE, pChannel->m_szIP, NS_PROTOCOL_PORT );
				}
			}
			break;

		case NSSOCK_ACCEPT:
			// a new device connect to us
			if ( !pChannel )
			{
				// if already receive it's broadcast
				pChannel = GetChannel( addr );

				// create a new device
				if ( !pChannel )
					pChannel = AddChannel( addr );
				else
					::NSSock_Disconnect( pChannel->m_socket );
			}

			if ( pChannel )
			{
				pChannel->SetSocket( socket );
				
				pChannel->Startup();
			}

			break;

		case NSSOCK_CLOSE:
			if ( pChannel )
#ifndef _103_LOG
				pChannel->ProcessClose();
#else
			{
				CTime tmNow = CTime::GetCurrentTime();

				CString szInfo = tmNow.Format( "%Y-%m-%d %H:%M:%S" );
				szInfo += "关闭SOCKET:\n\t通讯状态为\n\t";
				szInfo += "\t";
				szInfo += pChannel->m_szIP;

				char szTemp[12];
				sprintf( szTemp, ":%d\n", pChannel->m_socket );
				szInfo += szTemp;

				::Trace103Log( szInfo );
				
				pChannel->ProcessClose();
			}
#endif
			break;
	}
}

void C103App::TimerProc()
{
	// if it's time to broadcast name
	m_uBroadcastCounter++;
	if ( m_uBroadcastCounter > m_uTimeBroadcast )
	{
		BroadcastName();
		m_uBroadcastCounter = 0;
	}

	// general interrogation
	m_uGICounter++;
	if ( m_uGICounter > m_uTimeGI )
	{
		m_uGICounter = 0;

		POSITION pos = m_ListEquipment.GetHeadPosition();
		while( pos )
		{
			CEquipment* pEquipment = m_ListEquipment.GetNext( pos );
			pEquipment->GI();
		}
	}

	// if it's time to sync. time on equipment
	if ( 0 != m_uTimeSync )
	{
		m_uSyncCounter++;
		if ( m_uSyncCounter > m_uTimeSync )
		{
			m_uSyncCounter = 0;
		
			POSITION pos = m_ListEquipment.GetHeadPosition();
			while( pos )
			{
				CEquipment* pEquipment = m_ListEquipment.GetNext( pos );
				pEquipment->TimeSync();
			}
		}
	}

	// timer to equipment
	POSITION pos = m_ListEquipment.GetHeadPosition();
	while( pos )
	{
		CEquipment* pEquipment = m_ListEquipment.GetNext( pos );
		pEquipment->OnTimer();
	}
}

/////////////////////////////////////////////////////////////////////////////
// The one and only C103App object

C103App theApp;

void FAR PASCAL EXPORT NSSockCallBack( UINT uMsg, const char FAR* addr, PORT port, SOCKET socket )
{
	theApp.NSSockCallBack( uMsg, addr, port, socket );
}

void FAR PASCAL EXPORT TimerProc( HWND, UINT, WPARAM, LPARAM )
{
	theApp.TimerProc();
}

int FAR PASCAL EXPORT InitPrem()
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	return theApp.InitPrem();
}

void FAR PASCAL EXPORT ExitPrem()
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	theApp.ExitPrem();
}

int FAR PASCAL EXPORT SendPremMessage( UINT msg, WPARAM wParam, LPARAM lParam )
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	return theApp.SendPremMessage( msg, wParam, lParam );
}