📄 nsclass.cpp

📁 规约转换 103.104 规约转换适用于电力系统
💻 CPP
📖 第 1 页 / 共 5 页
字号:

	// flag for 103 protect value
	//
	*(WORD*)pValue = (WORD)-1;
	pValue += sizeof(WORD);
	*pValue = m_btProtectKOD;
	pValue++;
	*pValue = m_ListValue.GetCount();
	pValue++;

	pos = m_ListValue.GetHeadPosition();
	while( pos )
	{
		CProtectValue* pProtectValue = m_ListValue.GetNext( pos );

		*pValue = pProtectValue->m_btCode;
		pValue++;
		
		switch( pProtectValue->m_nValueType )
		{
			case VALUETYPE_STRING:
				strcpy( (char*)pValue, pProtectValue->m_szValue );
				pValue += pProtectValue->m_szValue.GetLength() + 1;
				break;

			case VALUETYPE_FLOAT:
				*(float*)pValue = pProtectValue->m_fValue;
				pValue += sizeof(float);
				break;
		}
	}

	switch( m_nState )
	{
		case STATE_REQUESTVAL:
			::PostMessage( m_hProtectWnd, WM_LFPASKVALUE, 0, (LPARAM)m_pValue );
			m_nState = STATE_NONE;
			break;

		case STATE_REQUESTYB:
			::PostMessage( m_hProtectWnd, WM_LFPASKVALUE, 0, (LPARAM)m_pValue );
			m_nState = STATE_NONE;
			break;

			//遥测类(保护测量值)
		case STATE_REQUESTPROTANA:
			::PostMessage( m_hProtectWnd, WM_LFPASKANALOGUE, 0, (LPARAM)m_pValue );
			m_nState = STATE_NONE;
			break;

		default:
			m_nState = STATE_NONE;
			break;
	}
}

void CEquipment::ProcessSysSet( BYTE* pData )
{
	//不处理本组条目数
	if ( 0 == *( pData + 1 ) )
		return ;

	//条目
	switch( *( pData + 1 ) )
	{
		case SYS_INF_CURAREA:
		case SYS_INF_RUNAREA:
			m_btValue = *( pData + GIN_LEN + KOD_LEN + GDD_LEN );
			break;

		case SYS_INF_PULSEFZ:
			break;

		case SYS_INF_SIGRST:
			break;
	}
}

void CEquipment::ProcessValSet( BYTE* pData, BYTE btLen )
{
	//不处理本组条目数
	if ( 0 == *( pData + 1 ) )
		return ;

	switch( m_nState )
	{
		case STATE_REQUESTAREA:
		case STATE_REQUESTVAL:
		case STATE_REQUESTYB:
		case STATE_REQUESTPROTANA:
			break;

		default:
			return ;
			break;
	}

	// create a protect value object
	CProtectValue* pProtectValue = new CProtectValue();
	if ( !pProtectValue )
		return ;
	m_ListValue.AddTail( pProtectValue );
	
	//条目
	pProtectValue->m_btCode = *( pData + 1 );
	//数据类型
	pProtectValue->m_btDataType = *( pData + GIN_LEN + KOD_LEN );

	switch( pData[GIN_LEN] )
	{
		case KOD_VALUE:
		case KOD_DEFAULT:
		case KOD_FACTOR:
			switch( pProtectValue->m_btDataType )
			{
				case GDD_UINT:
					pProtectValue->m_fValue = *(WORD*)( pData + GIN_LEN + KOD_LEN + GDD_LEN );
					break;

				case GDD_INT:
					pProtectValue->m_fValue = *(short*)( pData + GIN_LEN + KOD_LEN + GDD_LEN );
					break;

				case GDD_VAL_Q:
					pProtectValue->m_fValue = ProcessMEA( pData + GIN_LEN + KOD_LEN + GDD_LEN );
					break;

				case GDD_2BITS:
				case GDD_1BIT:
					pProtectValue->m_fValue = *(BYTE*)( pData + GIN_LEN + KOD_LEN + GDD_LEN );
					break;

				case GDD_UFLOAT:
				case GDD_FLOAT:
				case GDD_REAL:
				case GDD_DOUBLE:
					pProtectValue->m_fValue = *(float*)( pData + GIN_LEN + KOD_LEN + GDD_LEN );
					break;
			}

			pProtectValue->m_nValueType = VALUETYPE_FLOAT;

			break;

		case KOD_RANGE:
			{
				char szTemp[128];

				switch( pProtectValue->m_btDataType )
				{
					case GDD_UINT:
						sprintf( szTemp, "%u-%u:%u", *(WORD*)( pData + GIN_LEN + KOD_LEN + GDD_LEN ), *(WORD*)( pData + GIN_LEN + KOD_LEN + GDD_LEN + sizeof(WORD) ), *(WORD*)( pData + GIN_LEN + KOD_LEN + GDD_LEN + sizeof(WORD) * 2 ) );
						break;

					case GDD_INT:
						sprintf( szTemp, "%d-%d:%d", *(short*)( pData + GIN_LEN + KOD_LEN + GDD_LEN ), *(short*)( pData + GIN_LEN + KOD_LEN + GDD_LEN + sizeof(short) ), *(short*)( pData + GIN_LEN + KOD_LEN + GDD_LEN + sizeof(short) * 2 ) );
						break;

					default:
						sprintf( szTemp, "%.2f-%.2f:%.2f", *(float*)( pData + GIN_LEN + KOD_LEN + GDD_LEN ), *(float*)( pData + GIN_LEN + KOD_LEN + GDD_LEN + sizeof(float) ), *(float*)( pData + GIN_LEN + KOD_LEN + GDD_LEN + sizeof(float) * 2 ) );
						break;
				}

				pProtectValue->m_szValue = szTemp;
				pProtectValue->m_nValueType = VALUETYPE_STRING;
			}
			break;

		case KOD_DESCRIPTION:
		case KOD_DIMENSION:
			{
				char lpTemp[128];
				memcpy( lpTemp, pData + GIN_LEN + KOD_LEN + GDD_LEN, btLen );
				lpTemp[btLen] = 0;
				pProtectValue->m_szValue = lpTemp;
				pProtectValue->m_nValueType = VALUETYPE_STRING;
			}
			break;

		case KOD_PRECISION:
			{
				char szTemp[32];
				sprintf( szTemp, "%u.%u", *( pData + GIN_LEN + KOD_LEN + GDD_LEN ), *( pData + GIN_LEN + KOD_LEN + GDD_LEN + 2 ) );

				pProtectValue->m_szValue = szTemp;
				pProtectValue->m_nValueType = VALUETYPE_STRING;
			}
			break;

		default:
			break;
	}
}

void CEquipment::ProcessAnaSet( BYTE* pData )
{
	//不处理本组条目数
	if ( 0 == *( pData + 1 ) )
		return ;

	//描述类别:实际值
	if ( KOD_VALUE != pData[GIN_LEN] )
		return ;

	int nOrder = theApp.GetPointOrder( m_LogicAddr.m_btType, TYPE_ANALOGUE, *pData, *( pData + 1 ) );
	if ( -1 == nOrder )
		return ;

	char szData[5 + sizeof(WORD) + sizeof(float)], *pRaw = szData;
	
	*(WORD*)pRaw = m_LogicAddr.m_wRtu;
	pRaw += sizeof(WORD);

	switch( pData[GIN_LEN + KOD_LEN] )
	{
		case GDD_UINT:
		case GDD_INT:
		case GDD_VAL_Q:
			*pRaw = ANALOG_RAW_DATA;
			break;

		case GDD_REAL:
			*pRaw = ANALOG_FLOAT_DATA;
			break;

		default:
			*pRaw = ANALOG_FLOAT_DATA;
			break;
	}

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

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

	switch( pData[GIN_LEN + KOD_LEN] )
	{
		case GDD_UINT:
		case GDD_INT:
			*(WORD*)pRaw = *(WORD*)( pData + GIN_LEN + KOD_LEN + GDD_LEN );
			break;

		case GDD_VAL_Q:
			*(WORD*)pRaw = ProcessMEA( pData + GIN_LEN + KOD_LEN + GDD_LEN );
			break;

		case GDD_REAL:
			*(float*)pRaw = *(float*)( pData + GIN_LEN + KOD_LEN + GDD_LEN );
			break;

		default:
			*(float*)pRaw = *(float*)( pData + GIN_LEN + KOD_LEN + GDD_LEN );
			break;
	}

	::WriteRdbData( szData );
}

void CEquipment::ProcessDgtSet( BYTE* pData )
{
	//不处理本组条目数
	if ( 0 == *( pData + 1 ) )
		return ;

	//描述类别:实际值
	if ( KOD_VALUE != pData[GIN_LEN] )
		return ;

	int nOrder = theApp.GetPointOrder( m_LogicAddr.m_btType, TYPE_DIGITAL, *pData, *( pData + 1 ) );
	if ( -1 == nOrder )
		return ;

	char szData[5 + 2 * sizeof(WORD) + sizeof(time_t) + sizeof(BYTE)], *pRaw = szData;

	*(WORD*)pRaw = m_LogicAddr.m_wRtu;
	pRaw += sizeof(WORD);

	switch( pData[GIN_LEN + KOD_LEN] )
	{
		case GDD_2BITS:
		case GDD_1BIT:
			*pRaw = DIGIT_RAW_DATA;
			pRaw++;

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

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

			if ( GDD_2BITS == pData[GIN_LEN + KOD_LEN] )
			{
				if ( pData[GIN_LEN + KOD_LEN + GDD_LEN] == 1 )
					*(BYTE*)pRaw = 0;
				else
					*(BYTE*)pRaw = 1;
			}
			else
				*(BYTE*)pRaw = pData[GIN_LEN + KOD_LEN + GDD_LEN];

			::WriteRdbData( szData );

			break;

		default:
			break;
	}
}

void CEquipment::ProcessPulSet( BYTE* pData )
{
	//本组条目数
	if ( 0 == *( pData + 1 ) )
		return ;

	//描述类别:实际值
	if ( KOD_VALUE != pData[GIN_LEN] )
		return ;

	if ( COT_ACKGW == m_btCot )
		return ;

	int nOrder = theApp.GetPointOrder( m_LogicAddr.m_btType, TYPE_PULSE, -1, *( pData + 1 ) );
	if ( -1 == nOrder )
		return ;

	char szData[5 + sizeof(WORD) + sizeof(DWORD)], *pRaw = szData;

	*(WORD*)pRaw = m_LogicAddr.m_wRtu;
	pRaw += sizeof(WORD);
	*pRaw = pData[GIN_LEN + KOD_LEN] == GDD_FLOAT ? PULSE_RAW_FLOAT : PULSE_RAW_DATA;
	pRaw++;
	*(WORD*)pRaw = sizeof(WORD) + sizeof(DWORD);
	pRaw += sizeof(WORD);

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

	switch( pData[GIN_LEN + KOD_LEN] )
	{
		case GDD_UINT:
		case GDD_INT:
			*(DWORD*)pRaw = *(DWORD*)( pData + GIN_LEN + KOD_LEN + GDD_LEN );
			break;

		case GDD_FLOAT:
			*(DWORD*)pRaw = (DWORD)*(float*)( pData + GIN_LEN + KOD_LEN + GDD_LEN );
			break;

		default:
			*(DWORD*)pRaw = 0;
			break;
	}

	::WriteRdbData( szData );
}

void CEquipment::CheckUnprocess()
{
	while( !m_ListUnprocess.IsEmpty() )
	{
		PROTEVENT* pProtEvent = (PROTEVENT*)m_ListUnprocess.RemoveHead();
		strncpy( pProtEvent->szExplain, GetEvtExplain( pProtEvent->btType, pProtEvent->btMessage ), EVENTEXPLEN );
		
		::ProcessProPacket( pProtEvent );

		delete pProtEvent;
	}
}

void CEquipment::ProcessProtEvt( PROTEVENT* pProtEvent )
{
	if ( PROT_ACCIDENT == pProtEvent->btType )
	{
		if ( 0 == m_ListAccidentInf.GetCount() )
		{
			PROTEVENT* pNew = NULL;

			if ( MAX_PROTEVENT <= m_ListUnprocess.GetCount() )
				pNew = (PROTEVENT*)m_ListUnprocess.RemoveHead();
			else
				pNew = new PROTEVENT;

			if ( pNew )
			{
				memcpy( pNew, pProtEvent, sizeof( PROTEVENT ) );

				m_ListUnprocess.AddTail( pNew );
			}
			
			return ;
		}
	}
	else
	{
		if ( 0 == m_ListEventInf.GetCount() )
		{
			PROTEVENT* pNew = NULL;

			if ( MAX_PROTEVENT <= m_ListUnprocess.GetCount() )
				pNew = (PROTEVENT*)m_ListUnprocess.RemoveHead();
			else
				pNew = new PROTEVENT;

			if ( pNew )
			{
				memcpy( pNew, pProtEvent, sizeof( PROTEVENT ) );

				m_ListUnprocess.AddTail( pNew );
			}
			
			return ;
		}
	}
	
	::ProcessProPacket( pProtEvent );
}

CString CEquipment::GetEvtExplain( BYTE btType, BYTE btCode )
{
	if ( PROT_ACCIDENT == btType )
	{
		POSITION pos = m_ListAccidentInf.GetHeadPosition();
		while( pos )
		{
			CProtectValue* pProtectValue = m_ListAccidentInf.GetNext( pos );
			if ( btCode == pProtectValue->m_btCode )
				return pProtectValue->m_szValue;
		}
	}
	else
	{
		POSITION pos = m_ListEventInf.GetHeadPosition();
		while( pos )
		{
			CProtectValue* pProtectValue = m_ListEventInf.GetNext( pos );
			if ( btCode == pProtectValue->m_btCode )
				return pProtectValue->m_szValue;
		}
	}

	return "未定义";
}

void CEquipment::ProcessEvtSet( BYTE btType, BYTE* pData, int nLength )
{
	//不处理本组条目数
	if ( 0 == *( pData + 1 ) )
		return ;

	//描述类别:实际值
	if ( KOD_VALUE != pData[GIN_LEN] )
	{
		if ( KOD_DESCRIPTION == pData[GIN_LEN] )
		{
			CProtectValue* pProtectValue = new CProtectValue();
			if ( !pProtectValue )
				return ;

			if ( PROT_ACCIDENT == btType )
				m_ListAccidentInf.AddTail( pProtectValue );
			else
				m_ListEventInf.AddTail( pProtectValue );
	
			//条目
			pProtectValue->m_btCode = *( pData + 1 );

			char szTemp[1024];
			memcpy( szTemp, pData + GIN_LEN + KOD_LEN + GDD_LEN, nLength );
			szTemp[nLength] = 0;

			pProtectValue->m_szValue = szTemp;
		}

		return ;
	}

	PROTEVENT ProtEvent;
	memset( &ProtEvent, 0, sizeof( PROTEVENT ) );

	ProtEvent.btType = btType;
	ProtEvent.btDevice = (BYTE)m_LogicAddr.m_wNo;
	ProtEvent.btDevType = m_LogicAddr.m_btType;

	ProtEvent.btMessage = *( pData + 1 );
	
	strncpy( ProtEvent.szExplain, GetEvtExplain( btType, *( pData + 1 ) ), EVENTEXPLEN );

	if ( btType == PROT_ACCIDENT )
	{
		if ( pData[GIN_LEN + KOD_LEN + GDD_LEN] == 1 )
			strcat( ProtEvent.szExplain, "返回" );
		else
		{
			strcat( ProtEvent.szExplain, "动作" );

			// 2000.12.16 doo, for fault signal
			theApp.OnFaultSignal( TRUE );
		}
	}

	ProtEvent.wSum = 0;
	ProtEvent.evt_startms = m_LogicAddr.m_wRtu;

	switch( pData[GIN_LEN + KOD_LEN] )
	{
		case 18:
			ProcessTime( ProtEvent, pData + GIN_LEN + KOD_LEN + GDD_LEN + 1 );
			ProcessProtEvt( &ProtEvent );
			break;

		case 19:
			ProcessRelativeTime( ProtEvent, pData + GIN_LEN + KOD_LEN + GDD_LEN + 1 );
			ProcessTime( ProtEvent, pData + GIN_LEN + KOD_LEN + GDD_LEN + 1 + sizeof(WORD) );
			ProcessProtEvt( &ProtEvent );
			break;

		case 23:
			break;

		default:
			break;
	}
}

void CEquipment::ProcessInfSet( BYTE btType, BYTE* pData, int nLength )
{
	//不处理本组条目数
	if ( 0 == *( pData + 1 ) )
		return ;

	if ( KOD_DESCRIPTION == pData[GIN_LEN] )
	{
		CProtectValue* pProtectValue = new CProtectValue();
		if ( !pProtectValue )
			return ;

		if ( 0 == btType )
			m_ListChannelInf.AddTail( pProtectValue );
		else
			m_ListStateInf.AddTail( pProtectValue );
	
		//条目
		pProtectValue->m_btCode = *( pData + 1 );

		char szTemp[1024];
		memcpy( szTemp, pData + GIN_LEN + KOD_LEN + GDD_LEN, nLength );
		szTemp[nLength] = 0;

		pProtectValue->m_szValue = szTemp;
	}
}

void CEquipment::ProcessRlySet( BYTE btInf, BYTE* pData )
{
	//本组条目数
	if ( 0 == *( pData + 1 ) )
		return ;

	//描述类别:实际值
	if ( 1 != pData[GIN_LEN] )
		return ;

	// not from the right device
	if ( m_LogicAddr.m_wRtu != m_wRelayRtu )
		return ;
					
	// relay value not same
	BYTE btValue = 0;
	if ( -1 == theApp.GetRelayCode( m_LogicAddr.m_btType, m_wRelayIndex, m_btRelayValue, btValue ) )
		return ;

	if ( *( pData + GIN_LEN + KOD_LEN + GDD_LEN ) != btValue )
		return ;

	if ( COT_ACKGW == m_btCot )
		::PremCallBack( m_wRelayRtu, m_wRelayIndex, SELECT_SUC );
	else
		::PremCallBack( m_wRelayRtu, m_wRelayIndex, SELECT_FAIL );
}

void CEquipment::ProcessSOESet( BYTE* pData )
{
	//不处理本组条目数
	if ( 0 == *( pData + 1 ) )
		return ;

	//描述类别:实际值
	if ( 1 != pData[GIN_LEN] )
		return ;

	int nOrder = theApp.GetPointOrder( m_LogicAddr.m_btType, TYPE_DIGITAL, GRP_DGT1, *( pData + 1 ) );
	if ( -1 == nOrder )
		return ;

	char szData[5 + 2 * sizeof(WORD) + sizeof(time_t) + sizeof(BYTE)], *pRaw = szData;

	*(WORD*)pRaw = m_LogicAddr.m_wRtu;
	pRaw += sizeof(WORD);

	*pRaw = SOE_RAW_DATA;
	pRaw++;

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

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

	pData += GIN_LEN + KOD_LEN + GDD_LEN;
	if ( *pData == 1 )
		*(BYTE*)pRaw = 0;
	else
		*(BYTE*)pRaw = 1;
	pRaw++;
⌨️ 快捷键说明

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