asdu.cpp

电力系统Linux设备通讯程序 主要是为了各大电网通讯数据代码

#include "ASDU.h"

/////////// ASDU   /////////
CAsdu::CAsdu()
{
	m_ASDUData.SetSize(0);
	m_TYP		= 0;
	m_VSQ.byte	= 0;
	m_COT		= 0;
	m_Addr		= 0;
	m_FUN		= 0;
	m_INF		= 0;
	
	m_iResult = 0;
}

CAsdu::~CAsdu()
{
	m_ASDUData.SetSize(0);
}

void CAsdu::SaveAsdu(CByteArray& Data)
{
	m_TYP		= Data[0];
	m_VSQ.byte	= Data[1];
	m_COT		= Data[2];
	m_Addr		= Data[3];
	m_FUN		= Data[4];
	m_INF		= Data[5];

	Data.RemoveAt(0, 6);

	m_ASDUData.SetSize(0);
	m_ASDUData.Copy(Data);
	m_ASDUData.FreeExtra();
	Data.SetSize(0);
}
/////////// ASDU01 /////////
CAsdu01::CAsdu01()
{
	m_Dpi.byte = 0x00;
	m_SIN = 0x00;
	memset(m_Cp32Time.byte, 0x00, sizeof(m_Cp32Time.byte));
}

void CAsdu01::ExplainAsdu(int iProcessType /* =0 */)
{
	if (iProcessType == 0)//标准103的ASDU1的解释处理
	{
		if (m_ASDUData.GetSize() < 6)
		{
			m_ASDUData.SetSize(0);
			m_iResult = 0;
			return;
		}
		if ((m_COT == 20) || (m_COT == 21))//当传送原因(COT)为命令的肯定或否定认可时，DPI无效
		{
			m_ASDUData.SetSize(0);	
			m_iResult = 2;
			return;
		}
		m_iResult = 1;
		m_Dpi.byte = m_ASDUData[0];
		memcpy(m_Cp32Time.byte, m_ASDUData.GetData()+1, sizeof(m_Cp32Time.byte));
	}
	
	m_ASDUData.SetSize(0);
}
/////////// ASDU02 /////////
CAsdu02::CAsdu02()
{
	m_Dpi.byte = 0x00;
	m_FAN = 0;
	m_SIN = 0x00;
	memset(m_Cp32Time.byte, 0x00, sizeof(m_Cp32Time.byte));
	memset(m_Cp32TimeRET.byte, 0x00, sizeof(m_Cp32TimeRET.byte));
}

void CAsdu02::ExplainAsdu(int iProcessType /* =0 */)
{
	if (iProcessType == 0)//标准103的ASDU2的解释处理
	{
		if (m_ASDUData.GetSize() != 10) 
		{
			m_ASDUData.SetSize(0);
			m_iResult = 0;
			return;
		}
		m_iResult = 1;
		m_Dpi.byte = m_ASDUData[0];
		m_ASDUData.RemoveAt(0);
		memcpy(&m_Cp32TimeRET.Time.Milliseconds, m_ASDUData.GetData(), 
			   sizeof(m_Cp32TimeRET.Time.Milliseconds));
		m_ASDUData.RemoveAt(0, sizeof(m_Cp32TimeRET.Time.Milliseconds));
		memcpy(&m_FAN, m_ASDUData.GetData(), sizeof(m_FAN));
		m_ASDUData.RemoveAt(0, sizeof(m_FAN));
		memcpy(m_Cp32Time.byte, m_ASDUData.GetData(), sizeof(m_Cp32Time.byte));
		m_ASDUData.RemoveAt(0, sizeof(m_Cp32Time.byte));
		m_SIN = m_ASDUData[0];
	}
	m_ASDUData.SetSize(0);
}
/////////// ASDU03 /////////
CAsdu03::CAsdu03()
{
	m_BPhaseCurrent.word = 0;
	m_ABPhaseLineVoltage.word = 0;
	m_PPower.word = 0;
	m_QPower.word = 0;
}

void CAsdu03::ExplainAsdu(int iProcessType /* =0 */)
{//有待验证
	if (iProcessType == 0)//标准103的ASDU3的解释处理
	{
		if (m_ASDUData.GetSize() != 8)
		{
			m_ASDUData.SetSize(0);
			m_iResult = 0;
			return;
		}
		m_iResult = 1;
		memcpy(&m_BPhaseCurrent.word, m_ASDUData.GetData(), 
			   sizeof(m_BPhaseCurrent.word));
		m_ASDUData.RemoveAt(0, sizeof(m_BPhaseCurrent.word));
		memcpy(&m_ABPhaseLineVoltage.word, m_ASDUData.GetData(), 
			   sizeof(m_ABPhaseLineVoltage.word));
		m_ASDUData.RemoveAt(0, sizeof(m_ABPhaseLineVoltage.word));
		memcpy(&m_PPower.word, m_ASDUData.GetData(), sizeof(m_PPower.word));
		m_ASDUData.RemoveAt(0, sizeof(m_PPower.word));
		memcpy(&m_QPower.word, m_ASDUData.GetData(), sizeof(m_QPower.word));
	}
	m_ASDUData.SetSize(0);
}
/////////// ASDU04 /////////
CAsdu04::CAsdu04()
{
	m_SCL = 0.0;
	m_FAN = 0;
	memset(m_Cp32Time.byte, 0x00, sizeof(m_Cp32Time.byte));
	memset(m_Cp32TimeRET.byte, 0x00, sizeof(m_Cp32TimeRET.byte));
}

void CAsdu04::ExplainAsdu(int iProcessType /* =0 */)
{
	if (iProcessType == 0)//标准103的ASDU4的解释处理
	{
		if (m_ASDUData.GetSize() != 12)
		{
			m_ASDUData.SetSize(0);
			m_iResult = 0;
			return;
		}
		m_iResult = 1;
		memcpy(&m_SCL, m_ASDUData.GetData(), sizeof(float));
		m_ASDUData.RemoveAt(0, sizeof(float));
		memcpy(&m_Cp32TimeRET.Time.Milliseconds, m_ASDUData.GetData(), 
			   sizeof(m_Cp32TimeRET.Time.Milliseconds));
		m_ASDUData.RemoveAt(0, sizeof(m_Cp32TimeRET.Time.Milliseconds));
		memcpy(&m_FAN, m_ASDUData.GetData(), sizeof(WORD));
		m_ASDUData.RemoveAt(0, sizeof(WORD));
		memcpy(m_Cp32Time.byte, m_ASDUData.GetData(), sizeof(m_Cp32Time.byte));
	}
	m_ASDUData.SetSize(0);
}
/////////// ASDU06 /////////
CAsdu06::CAsdu06()
{
	m_TYP = 0x06;
	m_VSQ.byte = 0x81;
	m_Addr = 0xff;
	m_COT = 0x08;
	m_FUN = 0xff;

	memset(m_Cp56Time2a.byte, 0x00, sizeof(m_Cp56Time2a.byte));
}

void CAsdu06::BulidArray(CByteArray& Data)
{
	Data.SetSize(6+sizeof(m_Cp56Time2a.byte));
	Data.SetAt(0, m_TYP);
	Data.SetAt(1, m_VSQ.byte);
	Data.SetAt(2, m_COT);
	Data.SetAt(3, m_Addr);
	Data.SetAt(4, m_FUN);
	Data.SetAt(5, m_INF);
	memcpy(&Data[6], m_Cp56Time2a.byte, sizeof(m_Cp56Time2a.byte));
}

void CAsdu06::ExplainAsdu(int iProcessType /* =0 */)
{
	if (iProcessType == 0)//标准103的ASDU6的解释处理
	{
		if (m_ASDUData.GetSize() != 7)
		{
			m_ASDUData.SetSize(0);
			m_iResult = 0;
			return;
		}
		m_iResult = 1;
		memcpy(m_Cp56Time2a.byte, m_ASDUData.GetData(), sizeof(m_Cp56Time2a.byte));
	}
	m_ASDUData.SetSize(0);
}
/////////// ASDU07 /////////
CAsdu07::CAsdu07()
{
	m_TYP = 0x07;
	m_VSQ.byte = 0x81;
	m_COT = 0x09;
	m_FUN = 0xff;
	
	m_SCN = 0x00;
}

void CAsdu07::BulidArray(CByteArray& Data)
{
	Data.SetSize(0);
	Data.Add(m_TYP);
	Data.Add(m_VSQ.byte);
	Data.Add(m_COT);
	Data.Add(m_Addr);
	Data.Add(m_FUN);
	Data.Add(m_INF);
	Data.Add(m_SCN);
	Data.FreeExtra();
	m_iResult = 1;
}
/////////// ASDU08 /////////
CAsdu08::CAsdu08()
{
	m_SCN = 0x00;
}

void CAsdu08::ExplainAsdu(int iProcessType /* =0 */)
{
	if (iProcessType == 0)//标准103的ASDU8的解释处理
	{
		if (m_ASDUData.GetSize() != 1)
		{
			m_ASDUData.SetSize(0);
			m_iResult = 0;
			return;
		}
		m_iResult = 1;
		m_SCN = m_ASDUData.GetAt(0);
	}
	m_ASDUData.SetSize(0);
}
/////////// ASDU09 /////////
CAsdu09::CAsdu09()
{
	memset(&m_APhaseCurrent.word, 0x00, sizeof(m_APhaseCurrent.word));
	memset(&m_BPhaseCurrent.word, 0x00, sizeof(m_BPhaseCurrent.word));
	memset(&m_CPhaseCurrent.word, 0x00, sizeof(m_CPhaseCurrent.word));
	memset(&m_APhaseVoltage.word, 0x00, sizeof(m_APhaseVoltage.word));
	memset(&m_BPhaseVoltage.word, 0x00, sizeof(m_BPhaseVoltage.word));
	memset(&m_CPhaseVoltage.word, 0x00, sizeof(m_CPhaseVoltage.word));
	memset(&m_PPower.word, 0x00, sizeof(m_PPower.word));
	memset(&m_QPower.word, 0x00, sizeof(m_QPower.word));
	memset(&m_Frequency.word, 0x00, sizeof(m_Frequency.word));
}

void CAsdu09::ExplainAsdu(int iProcessType /* =0 */)
{//有待验证
	if (iProcessType == 0)//标准103的ASDU9的解释处理
	{
		if (m_ASDUData.GetSize() != m_VSQ.vsq.num*2)
		{
			m_ASDUData.SetSize(0);
			m_iResult = 0;
			return;
		}
		m_iResult = 1;
		if (m_ASDUData.GetSize() >= (int)sizeof(m_APhaseCurrent.word))
		{
			memcpy(&m_APhaseCurrent.word, m_ASDUData.GetData(), sizeof(m_APhaseCurrent.word));
			m_ASDUData.RemoveAt(0, sizeof(m_APhaseCurrent.word));
		}
		if (m_ASDUData.GetSize() >= (int)sizeof(m_BPhaseCurrent.word))
		{
			memcpy(&m_BPhaseCurrent.word, m_ASDUData.GetData(), sizeof(m_BPhaseCurrent.word));
			m_ASDUData.RemoveAt(0, sizeof(m_BPhaseCurrent.word));
		}
		if (m_ASDUData.GetSize() >= (int)sizeof(m_CPhaseCurrent.word))
		{
			memcpy(&m_CPhaseCurrent.word, m_ASDUData.GetData(), sizeof(m_CPhaseCurrent.word));
			m_ASDUData.RemoveAt(0, sizeof(m_CPhaseCurrent.word));
		}
		if (m_ASDUData.GetSize() >= (int)sizeof(m_APhaseVoltage.word))
		{
			memcpy(&m_APhaseVoltage.word, m_ASDUData.GetData(), sizeof(m_APhaseVoltage.word));
			m_ASDUData.RemoveAt(0, sizeof(m_APhaseVoltage.word));
		}
		if (m_ASDUData.GetSize() >= (int)sizeof(m_BPhaseVoltage.word))
		{
			memcpy(&m_BPhaseVoltage.word, m_ASDUData.GetData(), sizeof(m_BPhaseVoltage.word));
			m_ASDUData.RemoveAt(0, sizeof(m_BPhaseVoltage.word));
		}
		if (m_ASDUData.GetSize() >= (int)sizeof(m_CPhaseVoltage.word))
		{
			memcpy(&m_CPhaseVoltage.word, m_ASDUData.GetData(), sizeof(m_CPhaseVoltage.word));
			m_ASDUData.RemoveAt(0, sizeof(m_CPhaseVoltage.word));
		}
		if (m_ASDUData.GetSize() >= (int)sizeof(m_PPower.word))
		{
			memcpy(&m_PPower.word, m_ASDUData.GetData(), sizeof(m_PPower.word));
			m_ASDUData.RemoveAt(0, sizeof(m_PPower.word));
		}
		if (m_ASDUData.GetSize() >= (int)sizeof(m_QPower.word))
		{
			memcpy(&m_QPower.word, m_ASDUData.GetData(), sizeof(m_QPower.word));
			m_ASDUData.RemoveAt(0, sizeof(m_QPower.word));
		}
		if (m_ASDUData.GetSize() >= (int)sizeof(m_Frequency.word))
		{
			memcpy(&m_Frequency.word, m_ASDUData.GetData(), sizeof(m_Frequency.word));
			m_ASDUData.RemoveAt(0, sizeof(m_Frequency.word));
		}
		m_ASDUData.FreeExtra();
	}
	m_ASDUData.SetSize(0);
}
/////////// ASDU10 /////////
CAsdu10::CAsdu10()
{
	m_RII = 0x00;
	m_NGD.byte = 0x00;
	m_DataSets.clear();
	m_DataSets.setAutoDelete(true);
}

CAsdu10::~CAsdu10()
{
	m_DataSets.clear();
}

void CAsdu10::Init()
{
	m_TYP = 0x0a;
	m_VSQ.byte = 0x81;
	m_COT = 0x28;
	m_FUN = 0xfe;
	m_INF = 0xf1;
	m_RII = 0xff;	
	m_NGD.byte = 0x00;
}

void CAsdu10::ExplainAsdu(int iProcessType /* =0 */)
{
	if (iProcessType == 0)//标准103的ASDU10的解释处理
	{
		m_RII = m_ASDUData[0];
		m_NGD.byte = m_ASDUData[1];
		m_ASDUData.RemoveAt(0, 2);
		m_ASDUData.FreeExtra();
		
		int i = 0;
		DataSet* pDataSet = NULL;
		m_iResult = 1;
		for (i=0; i<m_NGD.ngd.No; i++)
		{
			if (m_ASDUData.GetSize() >= (int)(6*sizeof(BYTE)))
			{
				pDataSet = new DataSet;
				pDataSet->gin.GROUP = m_ASDUData[0];
				pDataSet->gin.ENTRY = m_ASDUData[1];
				pDataSet->kod = m_ASDUData[2];
				memcpy(pDataSet->gdd.byte, m_ASDUData.GetData()+3*sizeof(BYTE), sizeof(pDataSet->gdd.byte));
				pDataSet->gid.SetSize(pDataSet->gdd.gdd.DataSize*pDataSet->gdd.gdd.Number*sizeof(BYTE));
				memcpy(pDataSet->gid.GetData(), m_ASDUData.GetData()+3*sizeof(BYTE)+sizeof(pDataSet->gdd.byte), pDataSet->gid.GetSize()*sizeof(BYTE));
				m_DataSets.append(pDataSet);
				m_ASDUData.RemoveAt(0, 3*sizeof(BYTE)+sizeof(pDataSet->gdd.byte)+pDataSet->gdd.gdd.DataSize*pDataSet->gdd.gdd.Number*sizeof(BYTE));
				m_ASDUData.FreeExtra();
			}
			else
			{
				m_iResult = 0;				
				break;
			}
		}
	}
	m_ASDUData.SetSize(0);
}

void CAsdu10::BulidArray(CByteArray& Data)
{
	if (m_NGD.ngd.No != m_DataSets.count())
	{
		m_iResult = 0;
		return;
	}
	m_iResult = 1;
	Data.SetSize(0);
	Data.Add(m_TYP);
	Data.Add(m_VSQ.byte);
	Data.Add(m_COT);
	Data.Add(m_Addr);
	Data.Add(m_FUN);
	Data.Add(m_INF);
	Data.Add(m_RII);
	Data.Add(m_NGD.byte);
	DataSet* pDataSet = NULL;
	for (int i=0; i<m_NGD.ngd.No; i++)
	{