103function.cpp

为电力系统开发保护设备装置通讯的源代码 采用串口通讯, ret hat 9下 QT开发

#include "103Function.h"
#include <qfile.h>
#include <qdatetime.h>
#include <time.h>
#include "baseclass/publicclass.h"

//////////////////////////////////////////////////////////////////////
// CModfiyDingzhi
//////////////////////////////////////////////////////////////////////
CModfiyDingzhi::CModfiyDingzhi()
{
	m_bGroup = 0x00;
	m_bEntry = 0x00;
	m_bType = 0x00;
	m_bLen = 0x00;
}

//////////////////////////////////////////////////////////////////////
// CDistrubData
//////////////////////////////////////////////////////////////////////
CDistrubData::CDistrubData()
{
	m_iNOE = 0;
	m_iNOC = 0;
	m_iFAN = 0;
	m_iINT = 0;
}

CDistrubData::~CDistrubData()
{

}

void CDistrubData::SaveACCInfo(BYTE* pData)
{
	ACCInfo aData;
	aData.ACC = pData[0];
	aData.RPV = *(float*)(pData+1);
	aData.RSV = *(float*)(pData+5);
	aData.RFA = *(float*)(pData+9);
	m_ACCInfo.Add(aData);
}

void CDistrubData::SaveACCInfo(BYTE ACC, float RPV, float RSV, float RFA)
{
	ACCInfo aData;
	aData.ACC = ACC;
	aData.RPV = RPV;
	aData.RSV = RSV;
	aData.RFA = RFA;
	m_ACCInfo.Add(aData);
}

void CDistrubData::SaveSwitchData(BYTE* pData)
{
	m_SwitchDataNOT.Add(pData[0]);
	SwitchData sData;	
	memset(sData.byte, 0x00, 5*sizeof(BYTE));
	int index = 3;
	WORD wtmp = 0;
	memcpy(&wtmp, &pData[1], 2*sizeof(BYTE));
	if ((wtmp == 0) && (m_SwitchDataNOT.GetSize() == 2))
	{
		m_SwitchDataNOT.RemoveAt(1);
		m_SwitchDataNOT.SetAt(0, m_SwitchDataNOT.GetAt(0)+pData[0]);
	}
	for (int i=0; i<pData[0]; i++)
	{
		sData.data.TAP = wtmp;
		memcpy(sData.byte+2, &pData[index], 3*sizeof(BYTE));
		index += 3;
		m_SwitchData.Add(sData);
	}
}

void CDistrubData::SaveChannelData(BYTE* pData)
{
	CChannelData* pcData;
	WORD wtmp = 0;	
	int iACC = 0;	
	int step = 0;
	if (m_ChannelData.count() == 0)
	{
		iACC = 0;//南自网络103设备的通道号不能为0
	}
	else
	{
		pcData = m_ChannelData.at(m_ChannelData.count()-1);
		iACC = pcData->m_ACC;
	}
	if (iACC == (int)pData[0])
	{
		pcData = m_ChannelData.at(m_ChannelData.count()-1);
		pcData->m_NDV.Add(pData[1]);
		wtmp = *(WORD*)(pData+2);
		pcData->m_NFE.Add(wtmp);
		step = 0;
		int iNDV = pcData->m_NDV.GetAt(pcData->m_NDV.GetSize()-1);
		for (int i=0; i<iNDV; i++)
		{
			wtmp = *(WORD*)(pData+4+step);
			step += 2;
			pcData->m_SDV.Add(wtmp);
		}
	}
	else
	{
		pcData = new CChannelData;
		pcData->m_ACC = pData[0];
		pcData->m_NDV.Add(pData[1]);
		wtmp = *(WORD*)(pData+2);
		pcData->m_NFE.Add(wtmp);
		step = 0;
		for (int i=0; i<pcData->m_NDV[0]; i++)
		{
			wtmp = *(WORD*)(pData+4+step);
			step += 2;
			pcData->m_SDV.Add(wtmp);
		}
		m_ChannelData.append(pcData);
	}
}

CString CDistrubData::CreateWaveFile(int iCpuNo, CString szFilePath, CP56Time2a& FaultTime)
{
	CString strtmp = "";
	strtmp.sprintf("%s%04d%02d%02d%02d%02d%02d%03d-%d", szFilePath.data(), 
				   m_FaultDataTime.Time.Years+2000, m_FaultDataTime.Time.Months, 
				   m_FaultDataTime.Time.DaysOfMonth, m_FaultDataTime.Time.Hours, 
				   m_FaultDataTime.Time.Minutes, m_FaultDataTime.Time.Milliseconds/1000, 
				   m_FaultDataTime.Time.Milliseconds%1000, m_iFAN);
	
	if (!SortData())
	{
		DeleteData();
		return "";
	}
	if (CreateDATFile(strtmp))
	{
		CreateCFGFile(iCpuNo, strtmp);
	}
	else
	{
		strtmp = "";
	}
	DeleteData();
	
	FormatDataTime(FaultTime);
	return strtmp;
}

void CDistrubData::FormatDataTime(CP56Time2a& FaultTime)
{
	int itmp = 1000000/m_iINT;
	itmp = m_iNOE*1000/itmp;
	int imill = m_FaultDataTime.Time.Milliseconds%1000+itmp;
	struct tm olddatetime;
	olddatetime.tm_sec = m_FaultDataTime.Time.Milliseconds/1000;
	olddatetime.tm_min = m_FaultDataTime.Time.Minutes;
	olddatetime.tm_hour = m_FaultDataTime.Time.Hours;
	olddatetime.tm_mday = m_FaultDataTime.Time.DaysOfMonth;
	olddatetime.tm_mon = m_FaultDataTime.Time.Months;
	olddatetime.tm_year = m_FaultDataTime.Time.Years+2000-1900;
	time_t iold = mktime(&olddatetime);
	struct tm newdatetime;
	memset(&newdatetime, 0x00, sizeof(struct tm));
	newdatetime.tm_sec = 0;
	newdatetime.tm_min = 0;
	newdatetime.tm_hour = 0;
	newdatetime.tm_mday = 1;
	newdatetime.tm_mon = 1;
	newdatetime.tm_year = 1970;

	if (imill >= 1000)
	{
		newdatetime.tm_sec = imill/1000;
		time_t inew = iold+imill/1000;//mktime(&newdatetime);
		struct tm* pdatetime = localtime(&inew);
		memcpy(&newdatetime, pdatetime, sizeof(struct tm));
	}
	else
	{
		memcpy(&newdatetime, &olddatetime, sizeof(struct tm));
	}
	
	memset(FaultTime.byte, 0x00, sizeof(FaultTime.byte));
	FaultTime.Time.Years = (BYTE)(newdatetime.tm_year+1900-2000);
	FaultTime.Time.Months = (BYTE)newdatetime.tm_mon;
	FaultTime.Time.DaysOfMonth = (BYTE)newdatetime.tm_mday;
	FaultTime.Time.Hours = (BYTE)newdatetime.tm_hour;
	FaultTime.Time.Minutes = (BYTE)newdatetime.tm_min;
	FaultTime.Time.Milliseconds = newdatetime.tm_sec*1000+imill%1000;
}

void CDistrubData::CreateCFGFile(int iCpuNo, CString szFileName)
{
	szFileName += ".cfg";
	CString strtmp = "";
	QFile fFile(szFileName);

	if (!fFile.open(IO_WriteOnly)) return;
	QTextStream ts(&fFile);
	strtmp.sprintf("%sCPU%d,%d\r\n", m_szDeviceName.data(), iCpuNo, m_iDeviceNo);
	ts<<strtmp;
	
	m_iAnalogSum = m_ACCInfo.GetSize();
	m_iSwitchSum = m_SwitchDataNOT.GetAt(0);
	strtmp.sprintf("%d,%dA,%dD\r\n", m_iAnalogSum+m_iSwitchSum, m_iAnalogSum, m_iSwitchSum);
	ts<<strtmp;
	
	CString szDesc1 = "", szDesc2 = "", sztmp = "", szfun = "", szinf = "";
	float fFactor = 0.0;		ACCInfo aData;
	int i = 0;
	sztmp.sprintf("%d", iCpuNo);
	QDomNode node, cnode;
	node = m_pXml->GetDomNode("body", "WAVANALOG", "cpuno", sztmp);
	if (node.isNull()) return;
	for (i=1; i<=m_iAnalogSum; i++)
	{
		aData = m_ACCInfo.GetAt(i-1);
		fFactor = 1/aData.RFA;
		sztmp.sprintf("%d", aData.ACC);
		cnode = m_pXml->GetChildNode(node, "ELEMENT", "no", sztmp);
		if (!m_pXml->GetNodeAttr(cnode, "value1", szDesc1)) return;
		if (!m_pXml->GetNodeAttr(cnode, "value2", szDesc2)) return;

		strtmp.sprintf("%d,", i);
		strtmp += m_szLineName;
		strtmp += " ";
		strtmp += szDesc1;
		CString szfactor = "";
		szfactor.sprintf("%g", fFactor);
		strtmp += szfactor;
		strtmp += szDesc2;
		strtmp += "\r\n";
		strtmp = _T(strtmp);
		ts<<strtmp;
	}
	
	SwitchData sData;
	sztmp.sprintf("%d", iCpuNo);
	node = m_pXml->GetDomNode("body", "WAVSWITCH", "cpuno", sztmp);
	if (node.isNull()) return;
	for (i=1; i<=m_iSwitchSum; i++)
	{
		sData = m_SwitchData.GetAt(i-1);
		szfun.sprintf("%d", sData.data.FUN);
		szinf.sprintf("%d", sData.data.INF);
		cnode = m_pXml->GetChildNode(node, "ELEMENT", "fun", szfun, "inf", szinf);
		if (cnode.isNull())
		{
			szDesc1.sprintf("NOTFIND FUN:%d INF:%d", sData.data.FUN, sData.data.INF);
			szDesc2 = "1";
		}
		else
		{
			if (!m_pXml->GetNodeAttr(cnode, "desc", szDesc1)) return;
			if (!m_pXml->GetNodeAttr(cnode, "value", szDesc2)) return;
		}

		strtmp.sprintf("%d,", m_iAnalogSum+i);
		strtmp += m_szLineName;
		strtmp += " ",
		strtmp += szDesc1;
		strtmp += ",";
		strtmp += szDesc2;
		strtmp += "\r\n";
		strtmp = _T(strtmp);
		ts<<strtmp;
	}
	
	strtmp.sprintf("50\r\n");
	ts<<strtmp;
	strtmp.sprintf("1\r\n");
	ts<<strtmp;
	strtmp.sprintf("%d,%d\r\n", 1000000/m_iINT, m_iNOE);
	ts<<strtmp;
	
	strtmp.sprintf("%02d/%02d/%d,%02d:%02d:%02d.%03d\r\n", m_FaultDataTime.Time.Months, 
				   m_FaultDataTime.Time.DaysOfMonth, m_FaultDataTime.Time.Years, 
				   m_FaultDataTime.Time.Hours, m_FaultDataTime.Time.Minutes, 
				   m_FaultDataTime.Time.Milliseconds/1000, 
				   m_FaultDataTime.Time.Milliseconds%1000);
	ts<<strtmp;
	
	strtmp.sprintf("%02d/%02d/%d,%02d:%02d:%02d.%03d\r\n", m_FaultStartTime.Time.Months, 
				   m_FaultStartTime.Time.DaysOfMonth, m_FaultStartTime.Time.Years, 
				   m_FaultStartTime.Time.Hours, m_FaultStartTime.Time.Minutes, 
				   m_FaultStartTime.Time.Milliseconds/1000, 
				   m_FaultStartTime.Time.Milliseconds%1000);
	ts<<strtmp;
	strtmp.sprintf("BINARY\r\n");
	ts<<strtmp;
	fFile.close();
}

BOOL CDistrubData::CreateDATFile(CString szFileName)
{
	szFileName += ".dat";
	CString strtmp = "";
	QFile fFile(szFileName);

	int index = 1, iInt = 0, i = 0, j = 0, k = 0, iSwitchPoint = 0, nLen = 0;
	CChannelData* pcData;
	SwitchData sData;
	WORD tmp = 0;
	
	if (m_SwitchDataNOT.GetSize() == 0) return FALSE;

	if (m_SwitchDataNOT.GetAt(0)%16 > 0)
		iSwitchPoint = m_SwitchDataNOT.GetAt(0)/16+1;
	else iSwitchPoint = m_SwitchDataNOT.GetAt(0)/16;
	nLen = 4+m_iNOC+iSwitchPoint;
	WORD* pData = new WORD[m_iNOE*nLen];
	memset(pData, 0x00, m_iNOE*nLen*sizeof(WORD));

	pcData = m_ChannelData.at(0);
	if (m_iNOE > pcData->m_SDV.GetSize())
	{
		m_iNOE = pcData->m_SDV.GetSize();
	}
	for (i=0; i<m_iNOE; i++)
	{
		memcpy(&pData[i*nLen], &index, sizeof(int));//采样点序号
		for (j=0; j<m_iNOC; j++)//处理所有通道的第i个采样点
		{
			if (j < (int)m_ChannelData.count())
			{
				pcData = m_ChannelData.at(j);
				if (i < pcData->m_SDV.GetSize())
				{
					tmp = pcData->m_SDV[i];
					memcpy(&pData[i*nLen+4+j], &tmp, sizeof(WORD));
				}
				else 
				{
					delete [] pData;
					fFile.close();	return FALSE;
				}
			}
			else 
			{
				delete [] pData;
				fFile.close();	return FALSE;
			}
		}
		index++;
	}
	
	pcData = m_ChannelData.at(0);	j = 0;	index = 0;
	int* iTimeArray = new int[m_iNOE];
	memset(iTimeArray, 0, m_iNOE);
	int ipinglv = 1000000/m_iINT;
	for (i=0; i<m_iNOE; i++)
	{
		iInt = index*1000000/ipinglv;
		memcpy(&iTimeArray[i], &iInt, sizeof(int));//采样点的相对时间
		if ((pcData->m_NDV[j]+k) < i+1)
		{
			if (j < pcData->m_NDV.GetSize())
			{
				k += pcData->m_NDV[j];
				j++;
				index = pcData->m_NFE[j]+1;
			}
			continue;
		}
		index++;
	}
	pcData = m_ChannelData.at(0);	j = 0;	index = 0;	k = 0;
	for (i=0; i<m_iNOE; i++)
	{
		iInt = index;
		memcpy(&pData[i*nLen+2], &iInt, sizeof(int));//采样点的相对时间
		if ((pcData->m_NDV[j]+k) < i+1)
		{
			if (j < pcData->m_NDV.GetSize())
			{
				k += pcData->m_NDV[j];
				j++;
				index = pcData->m_NFE[j]+1;
			}
			continue;
		}
		index++;
	}

	WORD* wSwitchPoint = new WORD[iSwitchPoint*m_iNOE];
	memset(wSwitchPoint, 0x00, iSwitchPoint*m_iNOE*sizeof(WORD));
	WORD wtmp = 0;	index = 0;

	for(j=0; j<m_SwitchDataNOT.GetAt(0); j++,index++)//给开关量赋初始状态值
	{
		if (index <= m_SwitchData.GetSize())
		{
			sData = m_SwitchData.GetAt(index);
			wtmp = sData.data.DPI-1;
		}
		wtmp = wtmp << (j%16);
		wSwitchPoint[j/16] = wSwitchPoint[j/16]|wtmp;
	}

	for (i=0; i<m_iNOE; i++)//把所有采样点的开关的值赋为初始值
	{
		memcpy(&wSwitchPoint[i*iSwitchPoint], &wSwitchPoint[0], iSwitchPoint*sizeof(WORD));
	}
	WORD wtmp1 = 0;	int inf = 0;
	for (i=1; i<m_SwitchDataNOT.GetSize(); i++)//把所有的开关变位赋值
	{
		for (j=0; j<m_SwitchDataNOT.GetAt(i); j++)
		{
			sData = m_SwitchData.GetAt(index++);
			wtmp = sData.data.TAP;
			for (k=0; k<m_iNOE; k++)
			{
				memcpy(&wtmp1, &pData[k*nLen+2], sizeof(WORD));
				if (wtmp1 == wtmp) break;
			}
			inf = FindSwitch(sData);
			if (inf != 0)
			{
				memcpy(&wtmp, &wSwitchPoint[k*iSwitchPoint+(inf-1)/16], sizeof(WORD));
				wtmp = ChangeSwitch(wtmp, (inf-1)%16, sData.data.DPI);
				for (int a=k; a<m_iNOE; a++)
				{
					memcpy(&wSwitchPoint[a*iSwitchPoint+(inf-1)/16], &wtmp, sizeof(WORD));
				}
			}
		}
	}
	for (i=0; i<m_iNOE; i++)
	{
		memcpy(&pData[i*nLen+4+m_iNOC], &wSwitchPoint[i*iSwitchPoint], sizeof(WORD)*iSwitchPoint);
	}

	for (i=0; i<m_iNOE; i++)
	{
		memcpy(&pData[i*nLen+2], &iTimeArray[i], sizeof(int));//重新置采样时间,采样点的相对时间
	}

	if (!fFile.open(IO_WriteOnly))
	{
		delete [] iTimeArray;
		delete [] wSwitchPoint;
		delete [] pData;
		return FALSE;
	}
		
	fFile.writeBlock((char*)pData, m_iNOE*nLen*sizeof(WORD));
	fFile.close();

	delete [] iTimeArray;
	delete [] wSwitchPoint;
	delete [] pData;
	return TRUE;
}

void CDistrubData::DeleteData()
{
	int iSize = m_ChannelData.count();
	CChannelData* pcData;
	for (int i=0; i<iSize; i++)
	{
		pcData = m_ChannelData.at(i);
		if (pcData)
		{
			if (pcData->m_NDV.GetSize() > 0) pcData->m_NDV.SetSize(0);
			if (pcData->m_NFE.GetSize() > 0) pcData->m_NFE.SetSize(0);
			if (pcData->m_SDV.GetSize() > 0) pcData->m_SDV.SetSize(0);
			delete pcData;
		}
	}
	m_ACCInfo.SetSize(0);
	m_ChannelData.clear();
	m_SwitchDataNOT.SetSize(0);
	m_SwitchData.SetSize(0);
}

WORD CDistrubData::ChangeSwitch(WORD oldData, int no, int value)
{
	WORD wtmp = 0;
	WORD newData = 0;
	for (int i=0; i<16; i++)
	{
		if (i != no) wtmp = (oldData >> i) & 0x0001;
		else wtmp = value-1;
		wtmp = wtmp << i;
		newData = newData | wtmp;		
	}
	return newData;
}

int CDistrubData::FindSwitch(SwitchData sData)
{
	SwitchData tData;
	int iSize = m_SwitchDataSort.GetSize();
	for (int i=0; i<iSize; i++)
	{
		tData = m_SwitchDataSort.GetAt(i);
		if ((sData.data.FUN == tData.data.FUN) && (sData.data.INF == tData.data.INF))
			return tData.data.TAP;
	}
	return 0;
}

bool CDistrubData::SortData()
{
	CChannelData* pcData;
	ACCInfo AccInfo;
	int iSize = m_ChannelData.count();
	if (iSize == 0) return false;

	int* pAcc = new int[iSize];
	memset(pAcc, 0x00, iSize*sizeof(int));
	int i = 0;
	for (i=0; i<iSize; i++)
	{
		pcData = m_ChannelData.at(i);
		pAcc[i] = pcData->m_ACC;
	}
	int iTemp = 0;	int j = 0;	int k = 0;
	for (i=0; i<iSize; i++)
	{
		iTemp = pAcc[i];
		k = i;
		for (j=i; j<iSize; j++)
		{
			if (iTemp > pAcc[j])
			{
				iTemp = pAcc[j];
				k = j;
			}
		}
		pAcc[k] = pAcc[i];
		pAcc[i] = iTemp;
		pcData = m_ChannelData.at(k);
		AccInfo = m_ACCInfo.GetAt(k);
		m_ChannelData.replace(k, m_ChannelData.at(i));
		m_ChannelData.replace(i, pcData);
		m_ACCInfo.SetAt(k, m_ACCInfo.GetAt(i));
		m_ACCInfo.SetAt(i, AccInfo);
	}
	delete [] pAcc;

	if (m_SwitchDataNOT.GetSize() == 0) return false;
	iSize = m_SwitchDataNOT.GetAt(0);
	if (iSize > m_SwitchData.GetSize()) return false;//如果开关变位的个数少于初始的状态变位的个数，则数据有问题
	SwitchData sData1, sData2;	k = 0;
	int itime = 0;
	for (i=0; i<iSize; i++)
	{
		itime = 0;
		sData1 = m_SwitchData.GetAt(i);
		iTemp = sData1.data.FUN*255+sData1.data.INF;
		for (j=i; j<iSize; j++)
		{
			sData2 = m_SwitchData.GetAt(j);
			if (iTemp > sData2.data.FUN*255+sData2.data.INF)
			{
				iTemp = sData2.data.FUN*255+sData2.data.INF;
				k = j;
				itime++;
			}
		}
		if (itime > 0)
		{
			sData2 = m_SwitchData.GetAt(k);
			m_SwitchData.SetAt(i, sData2);
			m_SwitchData.SetAt(k, sData1);
		}
	}

	for (i=0; i<iSize; i++)
	{
		sData1 = m_SwitchData.GetAt(i);
		sData1.data.TAP = i+1;
		m_SwitchDataSort.Add(sData1);
	}
	return true;
}