nsclass.cpp

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

		if ( *pValue != pProtectValue->m_btCode )
		{
			pValue += 1 + sizeof(float);
			continue;
		}

		pValue++;

		// GIN
		*pTemp++ = GRP_VAL2;
		*pTemp++ = pProtectValue->m_btCode;

		// KOD
		*pTemp++ = KOD_VALUE;

		// GDD
		*pTemp++ = pProtectValue->m_btDataType;
		switch ( pProtectValue->m_btDataType )
		{
			case GDD_UINT:
				*pTemp++ = sizeof(WORD);
				*pTemp++ = 1;
				*(WORD*)pTemp = (WORD)( *(float*)pValue + 0.1 );
				pTemp += sizeof(WORD);
				m_nLength -= sizeof(float) - sizeof(WORD);
				break;

			case GDD_INT:
				*pTemp++ = sizeof(short);
				*pTemp++ = 1;
				*(short*)pTemp = (short)( *(float*)pValue + 0.1 );
				pTemp += sizeof(short);
				m_nLength -= sizeof(float) - sizeof(short);
				break;

			case GDD_UFLOAT:
			case GDD_FLOAT:
			case GDD_REAL:
			case GDD_DOUBLE:
				*pTemp++ = sizeof(float);
				*pTemp++ = 1;
				*(float*)pTemp = *(float*)pValue;
				pTemp += sizeof(float);
				break;
		}

		// value
		m_pValue[ASDUHEAD_DAT + 1]++;

		pValue += sizeof(float);

		wTotal--;
		if ( 0 == wTotal )
			break;
	}

	ProcessSend();
	
	return PREM_OK;
}

int CEquipment::RequestArea( WORD wRtu, HWND hWnd, BYTE btType )
{
	if ( STATE_GI < m_nState )
		return PREM_ERR_TASK;

	ClearList();

	m_nState = STATE_REQUESTAREA;
	
	m_wProtectRtu = wRtu;
	m_btProtectKOD = KOD_VALUE;
	m_hProtectWnd = hWnd;

	if ( 0 == btType )
		m_btInf = SYS_INF_CURAREA;
	else
		m_btInf = SYS_INF_RUNAREA;

	ProcessSend();
	
	return PREM_OK;
}

int CEquipment::ChangeArea( WORD wRtu, HWND hWnd, BYTE btType, BYTE btArea, APPSTATE appState )
{
	// is state free
	if ( STATE_GI < m_nState )
		return PREM_ERR_TASK;

	m_nState = appState;

	m_wProtectRtu = wRtu;
	m_hProtectWnd = hWnd;

	// free old data
	if ( m_pValue )
	{
		delete[] m_pValue;
		m_pValue = NULL;

		m_nLength = 0;
	}

	// allocate the buffer
	// modify only 1 per time
	m_nLength = ASDUHEAD_DAT + 2 + ( GIN_LEN + KOD_LEN + GDD_LEN + 1 );
	m_pValue = new BYTE[m_nLength];
	if ( !m_pValue )
		return PREM_ERR_MEMORY;

	// frame header
	m_pValue[ASDUHEAD_TYP] = ASDU_10;
	m_pValue[ASDUHEAD_VSQ] = 0x81;
	m_pValue[ASDUHEAD_COT] = COT_GW;
	m_pValue[ASDUHEAD_ADR] = m_LogicAddr.m_btAddrLgc;
	m_pValue[ASDUHEAD_FUN] = 254;

	switch( appState )
	{
		case STATE_CHANGEAREA:
			m_pValue[ASDUHEAD_INF] = ASDUINF_ACKW;
			break;

		case STATE_ACKCHANGEAREA:
			m_pValue[ASDUHEAD_INF] = ASDUINF_EXCW;
			break;

		case STATE_CANCELCHANGEAREA:
			m_pValue[ASDUHEAD_INF] = ASDUINF_CANW;
			break;
	}

	// RII
	m_pValue[ASDUHEAD_DAT] = m_btScn++;
	// NGD
	m_pValue[ASDUHEAD_DAT + 1] = 0;

	BYTE* pTemp = m_pValue + ASDUHEAD_DAT + 2;

	// GIN
	*pTemp++ = GRP_SYS1;
	if ( 0 == btType )
		*pTemp++ = SYS_INF_CURAREA;
	else
		*pTemp++ = SYS_INF_RUNAREA;

	// KOD
	*pTemp++ = KOD_VALUE;

	// GDD
	*pTemp++ = GDD_UINT;
	*pTemp++ = sizeof(BYTE);
	*pTemp++ = 1;
	*(BYTE*)pTemp = btArea;
	pTemp += sizeof(BYTE);

	// value
	m_pValue[ASDUHEAD_DAT + 1]++;

	ProcessSend();
	
	return PREM_OK;
}

int CEquipment::RequestYb( WORD wRtu, HWND hWnd, BYTE btKOD )
{
	if ( STATE_GI < m_nState )
		return PREM_ERR_TASK;

	ClearList();

	m_nState = STATE_REQUESTYB;
	
	m_wProtectRtu = wRtu;
	m_btProtectKOD = btKOD;
	m_hProtectWnd = hWnd;

	ProcessSend();
	
	return PREM_OK;
}

int CEquipment::ChangeYb( WORD wRtu, HWND hWnd, BYTE* pValue, APPSTATE appState )
{
	// is state free
	if ( STATE_GI < m_nState )
		return PREM_ERR_TASK;

	m_nState = appState;

	m_wProtectRtu = wRtu;
	m_hProtectWnd = hWnd;

	// free old data
	if ( m_pValue )
	{
		delete[] m_pValue;
		m_pValue = NULL;

		m_nLength = 0;
	}

	// allocate the buffer
	// modify only 1 per time
	m_nLength = ASDUHEAD_DAT + 2 + ( GIN_LEN + KOD_LEN + GDD_LEN + 1 );
	m_pValue = new BYTE[m_nLength];
	if ( !m_pValue )
		return PREM_ERR_MEMORY;

	// skip flag & total
	pValue += sizeof(WORD);
	WORD wTotal = *(WORD*)pValue;
	pValue += sizeof(WORD);

	// frame header
	m_pValue[ASDUHEAD_TYP] = ASDU_10;
	m_pValue[ASDUHEAD_VSQ] = 0x81;
	m_pValue[ASDUHEAD_COT] = COT_GW;
	m_pValue[ASDUHEAD_ADR] = m_LogicAddr.m_btAddrLgc;
	m_pValue[ASDUHEAD_FUN] = 254;

	switch( appState )
	{
		case STATE_CHANGEYB:
			m_pValue[ASDUHEAD_INF] = ASDUINF_ACKW;
			break;

		case STATE_ACKCHANGEYB:
			m_pValue[ASDUHEAD_INF] = ASDUINF_EXCW;
			break;

		case STATE_CANCELCHANGEYB:
			m_pValue[ASDUHEAD_INF] = ASDUINF_CANW;
			break;
	}

	// RII
	m_pValue[ASDUHEAD_DAT] = m_btScn++;
	// NGD
	m_pValue[ASDUHEAD_DAT + 1] = 0;

	BYTE* pTemp = m_pValue + ASDUHEAD_DAT + 2;

	// process the value
	POSITION pos = m_ListValue.GetHeadPosition();
	while( pos )
	{
		CProtectValue* pProtectValue = m_ListValue.GetNext( pos );

		if ( *pValue != pProtectValue->m_btCode )
		{
			pValue += 1 + sizeof(float);
			continue;
		}

		pValue++;

		if ( *(float*)pValue != pProtectValue->m_fValue )
		{
			// GIN
			*pTemp++ = GRP_RYB;
			*pTemp++ = pProtectValue->m_btCode;

			// KOD
			*pTemp++ = KOD_VALUE;

			// GDD
			*pTemp++ = pProtectValue->m_btDataType;
			switch (pProtectValue->m_btDataType)
			{
				case GDD_2BITS:
				case GDD_1BIT:
					*pTemp++ = sizeof(BYTE);
					*pTemp++ = 1;
					*(BYTE*)pTemp = (BYTE)( *(float*)pValue + 0.1 );
					pTemp += sizeof(BYTE);
					break;

				default:
					break;
			}

			// value
			m_pValue[ASDUHEAD_DAT + 1]++;

			break;
		}

		pValue += sizeof(float);

		wTotal--;
		if ( 0 == wTotal )
			return PREM_ERR_TASK;
	}
		
	ProcessSend();
	
	return PREM_OK;
}

int CEquipment::RequestProtAna( WORD wRtu, HWND hWnd, BYTE btKOD )
{
	if ( STATE_GI < m_nState )
		return PREM_ERR_TASK;

	ClearList();

	m_nState = STATE_REQUESTPROTANA;
	
	m_wProtectRtu = wRtu;
	m_btProtectKOD = btKOD;
	m_hProtectWnd = hWnd;

	ProcessSend();
	
	return PREM_OK;
}

int CEquipment::RequestRst( WORD wRtu, HWND hWnd )
{
	if ( STATE_GI < m_nState )
		return PREM_ERR_TASK;

	m_nState = STATE_RESET;
	
	m_wProtectRtu = wRtu;
	m_hProtectWnd = hWnd;

	ProcessSend();
	
	return PREM_OK;
}

int CEquipment::RequestAcc( WORD wRtu, HWND hWnd, BYTE btStep, WORD wOrder, BYTE btChannel )
{
	// get channel & state inf.
	if ( 0xFE == btStep )
	{
		// free old data
		if ( m_pValue )
		{
			delete[] m_pValue;
			m_pValue = NULL;
		}

		// data length
		int nLength = sizeof(BYTE) + sizeof(WORD) * 2 + m_ListChannelInf.GetCount() + m_ListStateInf.GetCount();

		POSITION pos = m_ListChannelInf.GetHeadPosition();
		while( pos )
		{
			CProtectValue* pProtectValue = m_ListChannelInf.GetNext( pos );
			nLength += pProtectValue->m_szValue.GetLength() + 1;
		}

		pos = m_ListStateInf.GetHeadPosition();
		while( pos )
		{
			CProtectValue* pProtectValue = m_ListChannelInf.GetNext( pos );
			nLength += pProtectValue->m_szValue.GetLength() + 1;
		}

		// allocate the buffer
		m_pValue = new BYTE[nLength];
		if ( !m_pValue )
			return PREM_ERR_MEMORY;
	
		BYTE* pValue = m_pValue;

		// step
		*pValue = 0xFE;
		pValue++;

		// total channel
		*(WORD*)pValue = m_ListChannelInf.GetCount();
		pValue += sizeof(WORD);

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

			*pValue = pProtectValue->m_btCode;
			pValue++;
			strcpy( (char*)pValue, pProtectValue->m_szValue );
			pValue += pProtectValue->m_szValue.GetLength() + 1;
		}

		// total state
		*(WORD*)pValue = m_ListStateInf.GetCount();
		pValue += sizeof(WORD);

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

			*pValue = pProtectValue->m_btCode;
			pValue++;
			strcpy( (char*)pValue, pProtectValue->m_szValue );
			pValue += pProtectValue->m_szValue.GetLength() + 1;
		}

		// notify online
		::PostMessage( hWnd, WM_LFPASKACCREPORT, nLength, (LPARAM)m_pValue );

		return PREM_OK;
	}

	if ( STATE_GI < m_nState )
		return PREM_ERR_TASK;

	m_nState = STATE_REQUESTACC;
	
	m_wProtectRtu = wRtu;
	m_hProtectWnd = hWnd;

	m_wOrder = wOrder;
	m_btStep = btStep;
	m_btChannel = btChannel;

	ProcessSend();
	
	return PREM_OK;
}

void CEquipment::OnAsdu5( BYTE* pData )
{
	// save version info.
	memset( m_szInfo, 0, sizeof(m_szInfo) );
	strncpy( m_szInfo, (char*)pData + ASDUHEAD_DAT + 1, 8 );
	memcpy( m_btInfo, pData + ASDUHEAD_DAT + 9, 4 );

	m_nState = STATE_NONE;
	m_uTaskTimeCounter = 0;

	// sync device time
	if ( 0 != theApp.m_uTimeSync )
		TimeSync();
	
	// load protect inf.
	LoadAccidentInf();
}

void CEquipment::EndProcess()
{
	switch( m_nState )
	{
		case STATE_RESET:
			m_nState = STATE_NONE;

			if ( COT_ACKYGW == m_btCot )
				::PostMessage( m_hProtectWnd, WM_LFPSIGRESETOK, 0, 0 );

			return ;

			break;

		case STATE_GI:
			if ( COT_GI == m_btCot )
				m_nState = STATE_NONE;

			return ;

			break;

		case STATE_ACCIDENTINF:
			m_nState = STATE_NONE;
			LoadEventInf();
			break;

		case STATE_EVENTINF:
			m_nState = STATE_NONE;
			LoadChannelInf();
			break;

		case STATE_CHANNELINF:
			m_nState = STATE_NONE;
			LoadStateInf();
			break;

		case STATE_STATEINF:
			m_nState = STATE_NONE;
			GI();
			CheckUnprocess();
			break;

		case STATE_FREEZEPULSE:
			m_nState = STATE_NONE;
			if ( COT_ACKYGW == m_btCot )
				CallPulse();
			else
				FreePulse();
			break;

		case STATE_CALLPULSE:
			m_nState = STATE_NONE;
			FreePulse();
			break;

		case STATE_REQUESTAREA:
			::PostMessage( m_hProtectWnd, WM_LFPASKAREA, 0, (LPARAM)m_btValue );
			m_nState = STATE_NONE;

			return ;

			break;

		case STATE_CHANGEAREA:
			if ( COT_ACKGW == m_btCot )
				::PostMessage( m_hProtectWnd, WM_LFPCHGAREA, 0, (LPARAM)m_btValue );
			else
				::PostMessage( m_hProtectWnd, WM_LFPCHGAREAERR, 0, (LPARAM)m_btValue );
			m_nState = STATE_NONE;

			return ;

			break;

		case STATE_ACKCHANGEAREA:
			if ( COT_ACKYGW == m_btCot )
				::PostMessage( m_hProtectWnd, WM_LFPCHGAREAOK, 0, (LPARAM)m_btValue );
			else
				::PostMessage( m_hProtectWnd, WM_LFPCHGAREAERR, 0, (LPARAM)m_btValue );
			m_nState = STATE_NONE;

			return ;

			break;

		case STATE_CHANGEVAL:
			if ( COT_ACKGW == m_btCot )
				::PostMessage( m_hProtectWnd, WM_LFPCHGVALUE, 0, 0 );
			else
				::PostMessage( m_hProtectWnd, WM_LFPCHGVALUERR, 0, 0 );
			m_nState = STATE_NONE;

			return ;

			break;

		case STATE_ACKCHANGEVAL:
			if ( COT_ACKYGW == m_btCot )
				::PostMessage( m_hProtectWnd, WM_LFPCHGVALUEOK, 0, 0 );
			else
				::PostMessage( m_hProtectWnd, WM_LFPCHGVALUERR, 0, 0 );
			m_nState = STATE_NONE;
			
			return ;

			break;

		case STATE_CHANGEYB:
			if ( COT_ACKGW == m_btCot )
				::PostMessage( m_hProtectWnd, WM_LFPCHGVALUE, 0, 0 );
			else
				::PostMessage( m_hProtectWnd, WM_LFPCHGVALUERR, 0, 0 );
			m_nState = STATE_NONE;

			return ;

			break;

		case STATE_ACKCHANGEYB:
			if ( COT_ACKYGW == m_btCot )
				::PostMessage( m_hProtectWnd, WM_LFPCHGVALUEOK, 0, 0 );
			else
				::PostMessage( m_hProtectWnd, WM_LFPCHGVALUERR, 0, 0 );
			m_nState = STATE_NONE;

			return ;

		default:
			break;
	}

	if ( m_ListValue.IsEmpty() )
		return ;

	// get data length
	int nLength = 0;

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

		switch( pProtectValue->m_nValueType )
		{
			case VALUETYPE_STRING:
				nLength += pProtectValue->m_szValue.GetLength() + 1;
				break;

			case VALUETYPE_FLOAT:
				nLength += sizeof(float);
				break;
		}

		// 1 byte code
		nLength += 1;
	}

	// free old data
	if ( m_pValue )
	{
		delete[] m_pValue;
		m_pValue = NULL;
	}

	// allocate the buffer
	m_pValue = new BYTE[sizeof(WORD) * 2 + nLength];
	if ( !m_pValue )
		return;

	BYTE* pValue = m_pValue;