103device.cpp~

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

		pNode->m_nodeinfo.m_iSize = szMsg.length()+1;
	}
	g_PublicClass.m_NodeManage.AddSendDataNode((void*)pNode);
}

bool C103Device::GetDistrubData()
{
	int iSize = m_DDTable.GetSize();
	
	DistrubDataTable Ddt;
	int iErrors = 0;
	int iHaveNoData = 0;
	
	CWordArray FanArray;
	WORD wFan = 0;
	WORD wNof = 0;
	for (int i=0; i<iSize;)
	{
		Ddt = m_DDTable.GetAt(0);
		for (int j=0; j<m_iCpuNum; j++)
		{
			it = m_CommParam.at(j);
			if ((*it).AsduAddress == Ddt.addr) break;
		}
		ResetCU();//初始化一次,否则在召唤BP2B的波形时下一个波形上不来
		if (!SendAsdu24(Ddt.FAN, 0x01, 0, 0)) return false;
		do {
			if (!RequestL1UserData())
			{
				FlibFCB();
				if (iErrors++ > 3) return false;
			}
			iErrors = 0;
			if (m_ReceData.GetSize() == 0)
			{
				if (iHaveNoData++ > 10) 
				{
					m_DistrubData.DeleteData();
					return false;
				}
				usleep(500);
			}
			else iHaveNoData = 0;
			if (m_ReceData.GetSize() > 0) ProcessData();
			
			if (m_DDStatus == 1)//成功传送一个扰动数据
			{
				m_DDStatus = 0;
				memcpy(m_DistrubData.m_FaultDataTime.byte, Ddt.Cp56Time.byte, 7*sizeof(BYTE));
				m_DistrubData.m_szLineName = CString(m_DevInfo.m_LineName);
				m_DistrubData.m_iDeviceNo = m_DevInfo.m_EquipNo;
				m_DistrubData.m_szDeviceName = CString(m_DevInfo.m_Equipment);
				m_DistrubData.m_iFAN = Ddt.FAN;
				
				int imill = m_iWavType+m_DistrubData.m_FaultDataTime.Time.Milliseconds%1000;
				if (imill > 1000)
				{
					struct tm timestart;
					timestart.tm_sec = m_DistrubData.m_FaultDataTime.Time.Milliseconds/1000;
					timestart.tm_min = m_DistrubData.m_FaultDataTime.Time.Minutes;
					timestart.tm_hour = m_DistrubData.m_FaultDataTime.Time.Hours;
					timestart.tm_mday = m_DistrubData.m_FaultDataTime.Time.DaysOfMonth;
					timestart.tm_mon = m_DistrubData.m_FaultDataTime.Time.Months;
					timestart.tm_year = m_DistrubData.m_FaultDataTime.Time.Years+2000-1900;
					
					time_t time = mktime(&timestart)+imill/1000;
					struct tm* ptimebegin = localtime(&time);
					
					m_DistrubData.m_FaultStartTime.Time.Years = ptimebegin->tm_year+1900-2000;
					m_DistrubData.m_FaultStartTime.Time.Months = ptimebegin->tm_mon;
					m_DistrubData.m_FaultStartTime.Time.DaysOfMonth = ptimebegin->tm_mday;
					m_DistrubData.m_FaultStartTime.Time.Hours = ptimebegin->tm_hour;
					m_DistrubData.m_FaultStartTime.Time.Minutes = ptimebegin->tm_min;
					m_DistrubData.m_FaultStartTime.Time.Milliseconds = ptimebegin->tm_sec*1000+imill%1000;
				}
				else
				{
					memcpy(m_DistrubData.m_FaultStartTime.byte, m_DistrubData.m_FaultDataTime.byte, 
						   sizeof(m_DistrubData.m_FaultDataTime.byte));
					m_DistrubData.m_FaultStartTime.Time.Milliseconds += m_iWavType;
				}
				CString szFileName = m_DistrubData.CreateWaveFile((*it).CpuNo, m_szSysPath, m_ThisTimeFTime);
				if (szFileName != "")
				{
					wFan = Ddt.FAN;
					
					if (m_iHaveWaveFile == 0)
					{
						m_iHaveWaveFile = 1;
						m_szWaveFileName = szFileName;
						memcpy(m_LastTimeFTime.byte, m_ThisTimeFTime.byte, sizeof(m_ThisTimeFTime.byte));
						FanArray.Add(Ddt.FAN);
						memcpy(m_LastFaultTime.byte, Ddt.Cp56Time.byte, sizeof(m_LastFaultTime.byte));
					}
					else
					{
						int itimespan = TimeSpan(Ddt.Cp56Time, m_LastTimeFTime);
						if (itimespan <= 100 && itimespan > -80)
						{
							m_iHaveWaveFile++;
							memcpy(m_LastTimeFTime.byte, m_ThisTimeFTime.byte, sizeof(m_ThisTimeFTime.byte));
							int iFirstTime = 0, iNoe = 0, iInt = 0;
							BuildCfgFile(szFileName, iNoe, iInt);
							iFirstTime = TimeSpan(Ddt.Cp56Time, m_LastFaultTime);
							iFirstTime *= 1000;
							BuildDatFile(szFileName, iFirstTime, iNoe, iInt);
							FanArray.Add(Ddt.FAN);
						}
						else
						{
							BuildHdrFile(m_szWaveFileName, FanArray);
							ProcessWave(wNof, m_szWaveFileName);
							m_iHaveWaveFile = 1;
							m_szWaveFileName = szFileName;
							memcpy(m_LastTimeFTime.byte, m_ThisTimeFTime.byte, sizeof(m_ThisTimeFTime.byte));
							FanArray.Add(Ddt.FAN);
							memcpy(m_LastFaultTime.byte, Ddt.Cp56Time.byte, sizeof(m_LastFaultTime.byte));
						}
					}
					m_DDTable.RemoveAt(0);
					m_DDTable.FreeExtra();
				}
				CString sztmp = "";
				sztmp.sprintf("%04d%02d%02d%02d%02d%05d", Ddt.Cp56Time.Time.Years+2000, Ddt.Cp56Time.Time.Months, 
							  Ddt.Cp56Time.Time.DaysOfMonth, Ddt.Cp56Time.Time.Hours, Ddt.Cp56Time.Time.Minutes, 
							  Ddt.Cp56Time.Time.Milliseconds);

				QDomNode node, cnode;
				node = m_pxml->GetDomNode("body", "DEVCONFIG");
				sztmp.sprintf("%s", m_DevInfo.m_Equipment);
				cnode = m_pxml->GetChildNode(node, "LASTWAVETIME", "devname", sztmp);
				sztmp.sprintf("%s", sztmp.data());
				m_pxml->InsertNodeAttr(cnode, "value", sztmp);
				m_pxml->SaveXmlFile();
				
				m_szLastWaveTime = sztmp;
				break;
			}
			else if (m_DDStatus == 2)//一个扰动数据传送失败
			{
				m_DDStatus = 0;
				m_DistrubData.DeleteData();
				m_DDTable.RemoveAt(0);
				m_DDTable.FreeExtra();
				break;
			}
		} while(1);
		iSize = m_DDTable.GetSize();
		wNof = Ddt.FAN;
	}
	if (m_iHaveWaveFile > 0)
	{
		BuildHdrFile(m_szWaveFileName, FanArray);
		ProcessWave(wNof, m_szWaveFileName);
		m_iHaveWaveFile = 0;
	}
	
	return true;
}

void C103Device::SortDDTable()
{
	int iSize = m_DDTable.GetSize();
	DistrubDataTable table1, table2;
	CString sztmp1 = "", sztmp2 = "";
	for (int i=0; i<iSize-1; i++)
	{
		table1 = m_DDTable.GetAt(i);
		sztmp1.sprintf("%04d%02d%02d%02d%02d%05d", table1.Cp56Time.Time.Years+2000, 
					   table1.Cp56Time.Time.Months, table1.Cp56Time.Time.DaysOfMonth, 
					   table1.Cp56Time.Time.Hours, table1.Cp56Time.Time.Minutes, 
					   table1.Cp56Time.Time.Milliseconds);
		for (int j=i+1; j<iSize; j++)
		{
			table2= m_DDTable.GetAt(j);
			sztmp2.sprintf("%04d%02d%02d%02d%02d%05d", table2.Cp56Time.Time.Years+2000, 
						   table2.Cp56Time.Time.Months, table2.Cp56Time.Time.DaysOfMonth, 
						   table2.Cp56Time.Time.Hours, table2.Cp56Time.Time.Minutes, 
						   table2.Cp56Time.Time.Milliseconds);
			if (strcmp(sztmp1, sztmp2) > 0)
			{
				m_DDTable.SetAt(i, table2);
				m_DDTable.SetAt(j, table1);
				table1 = m_DDTable.GetAt(i);
				sztmp1= sztmp2;
			}
			else if (strcmp(sztmp1, sztmp2) == 0)
			{
				m_DDTable.RemoveAt(j);
				iSize -= 1;
			}
		}
	}
}

int C103Device::TimeSpan(CP56Time2a FaultTime, CP56Time2a LastTime)
{
	struct tm newdatetime;
	newdatetime.tm_sec = FaultTime.Time.Milliseconds/1000;
	newdatetime.tm_min = FaultTime.Time.Minutes;
	newdatetime.tm_hour = FaultTime.Time.Hours;
	newdatetime.tm_mday = FaultTime.Time.DaysOfMonth;
	newdatetime.tm_mon = FaultTime.Time.Months;
	newdatetime.tm_year = FaultTime.Time.Years+2000-1900;
	
	struct tm olddatetime;
	olddatetime.tm_sec = LastTime.Time.Milliseconds/1000;
	olddatetime.tm_min = LastTime.Time.Minutes;
	olddatetime.tm_hour = LastTime.Time.Hours;
	olddatetime.tm_mday = LastTime.Time.DaysOfMonth;
	olddatetime.tm_mon = LastTime.Time.Months;
	olddatetime.tm_year = LastTime.Time.Years+2000-1900;
	
	int inew = mktime(&newdatetime);
	int iold = mktime(&olddatetime);
	int iTimeSpan = (inew-iold)*1000+FaultTime.Time.Milliseconds-LastTime.Time.Milliseconds;
	
	return iTimeSpan;
}

void C103Device::BuildCfgFile(CString szFileName, int& iNoe, int& iInt)
{
	CString sztmp = "";
	int i = 0;
	iNoe = 0;	iInt = 0;
	
	QFile fFile(m_szWaveFileName+".cfg");
	QFile fFilenew(szFileName+".cfg");
	QFile ftmp(m_szWaveFileName+".tmp");
	fFile.open(IO_ReadWrite);
	fFilenew.open(IO_ReadOnly);
	ftmp.open(IO_WriteOnly);
	char chtmp[1024];
	
	memset(chtmp, 0x00, sizeof(chtmp));
	fFile.readLine(chtmp, sizeof(chtmp));
	ftmp.writeBlock(chtmp, strlen(chtmp));
	memset(chtmp, 0x00, sizeof(chtmp));
	fFile.readLine(chtmp, sizeof(chtmp));	
	ftmp.writeBlock(chtmp, strlen(chtmp));
	fFilenew.readLine(chtmp, sizeof(chtmp));
	memset(chtmp, 0x00, sizeof(chtmp));
	fFilenew.readLine(chtmp, sizeof(chtmp));
	sztmp = CString(chtmp);
	sztmp = sztmp.left(sztmp.find(","));
	int itime = sztmp.toInt()+1;
	for (i=0; i<itime; i++)
	{
		memset(chtmp, 0x00, sizeof(chtmp));
		fFile.readLine(chtmp, sizeof(chtmp));
		ftmp.writeBlock(chtmp, strlen(chtmp));
		fFilenew.readLine(chtmp, sizeof(chtmp));
	}
	memset(chtmp, 0x00, sizeof(chtmp));
	fFile.readLine(chtmp, sizeof(chtmp));
	sztmp = CString(chtmp);
	itime = sztmp.toInt()+1;
	fFilenew.readLine(chtmp, sizeof(chtmp));
	sztmp.sprintf("%d\n", itime);
	ftmp.writeBlock(sztmp.data(), sztmp.length());
	for (i=0; i<itime-1; i++)
	{
		memset(chtmp, 0x00, sizeof(chtmp));
		fFile.readLine(chtmp, sizeof(chtmp));
		ftmp.writeBlock(chtmp, strlen(chtmp));
	}
	memset(chtmp, 0x00, sizeof(chtmp));
	fFilenew.readLine(chtmp, sizeof(chtmp));
	ftmp.writeBlock(chtmp, strlen(chtmp));
	memset(chtmp, 0x00, sizeof(chtmp));
	fFile.readLine(chtmp, sizeof(chtmp));
	ftmp.writeBlock(chtmp, strlen(chtmp));
	memset(chtmp, 0x00, sizeof(chtmp));
	fFile.readLine(chtmp, sizeof(chtmp));
	ftmp.writeBlock(chtmp, strlen(chtmp));
	memset(chtmp, 0x00, sizeof(chtmp));
	fFile.readLine(chtmp, sizeof(chtmp));
	ftmp.writeBlock(chtmp, strlen(chtmp));
	
	fFile.close();
	fFilenew.close();
	ftmp.close();
	QFile::remove(m_szWaveFileName+".cfg");
	QFile::remove(szFileName+".cfg");
	QDir d(m_szSysPath);
	d.rename(m_szWaveFileName+".tmp", m_szWaveFileName+".cfg");
}

void C103Device::BuildDatFile(CString szFileName, int iFirstTime, int iNoe, int iInt)
{
	QFile fFile(m_szWaveFileName+".dat");
	QFile fFilenew(szFileName+".dat");
	
	int iAnalogSum = m_DistrubData.m_iAnalogSum; 
	int iSwitchSum = m_DistrubData.m_iSwitchSum;
	int iLen = 0;
	if (iSwitchSum%16 == 0) iSwitchSum = iSwitchSum/16;
	else iSwitchSum = iSwitchSum/16+1;
	iLen = 4+iAnalogSum+iSwitchSum;
	WORD* wtmp = new WORD[iLen];
	memset(wtmp, 0, sizeof(WORD)*iLen);
	int itime = 0, index = 0;
	
	fFile.open(IO_ReadWrite);
	fFilenew.open(IO_ReadOnly);
	
	int iFileLen = fFile.size();
	fFile.at(iFileLen-iLen*2);
	fFile.readBlock((char*)wtmp, iLen*2);
	memcpy(&index, &wtmp[0], 2*sizeof(WORD));
	itime = iFirstTime;
	
	for (int i=0; i<iNoe; i++)
	{
		fFilenew.readBlock((char*)wtmp, iLen*2);
		index++;
		itime = iFirstTime+i*1000000/iInt;
		memcpy(&wtmp[0], &index, 2*sizeof(WORD));
		memcpy(&wtmp[2], &itime, 2*sizeof(WORD));
		fFile.writeBlock((char*)wtmp, iLen*2);
	}
	fFile.close();
	fFilenew.close();
	
	QFile::remove(szFileName+".cfg");
	QFile::remove(szFileName+".dat");
}

void C103Device::BuildHdrFile(CString szFileName, CWordArray& FanArray)
{
	QFile fFile(szFileName+".hdr");
	CString strtmp = "", sztmp = "";
	WORD iFan = 0;
	CFaultExplain FaultExplain;
	
	if (!fFile.open(IO_WriteOnly)) return;
	QTextStream ts(&fFile);
	strtmp = _T("南京银山网络：故障信息系统分析报告\r\n");
	ts<<strtmp;
	strtmp = _T("接入线路名称："+CString(m_DevInfo.m_LineName)+"\r\n");
	ts<<strtmp;
	strtmp = _T("接入设备名称："+CString(m_DevInfo.m_Equipment)+"\r\n");
	ts<<strtmp;
	strtmp = _T("接入设备型号："+CString(m_DevInfo.m_MachineType)+"\r\n");
	ts<<strtmp;
	strtmp = szFileName.right(szFileName.length()-szFileName.findRev('/')-1);
	strtmp = strtmp.left(strtmp.find('-'));
	sztmp = _T("故障发生时间："+strtmp+"\r\n");
	ts<<strtmp;
	strtmp = "\r\n";
	ts<<strtmp;
	
	for (int j=0; j<FanArray.GetSize(); j++)
	{
		iFan = FanArray.GetAt(j);
		for (int i=0; i<m_FaultExplain.GetSize(); i++)
		{
			FaultExplain = m_FaultExplain.GetAt(i);
			if (FaultExplain.m_FAN == iFan)
			{
				if (FaultExplain.m_iType == 1)
				{
					strtmp.sprintf("%gA", FaultExplain.m_MaxFaultCurrent);
					strtmp = _T("最大故障电流："+strtmp+"\r\n");
					ts<<strtmp;
				}
				else if (FaultExplain.m_iType == 2)
				{
					strtmp.sprintf("%gA", FaultExplain.m_MaxZeroCurrent);
					strtmp = _T("最大零序电流："+strtmp+"\r\n");
					ts<<strtmp;
				}
				else if (FaultExplain.m_iType == 3)
				{
					strtmp.sprintf("%gkM", FaultExplain.m_FaultDistance);
					strtmp = _T("短路位置："+strtmp+"\r\n");
					ts<<strtmp;
				}
				else if (FaultExplain.m_iType == 4)
				{
					if (FaultExplain.m_szFaultPhase.length() > 0)
					{
						strtmp = _T("故障选相："+FaultExplain.m_szFaultPhase+"\r\n");
						ts<<strtmp;
					}
				}
				m_FaultExplain.RemoveAt(i);
				i--;
			}
		}
	}
	
	strtmp = _T("录波分析结束！\r\n");
	ts<<strtmp;
	strtmp = _T("南京银山电子有限公司！\r\n");
	ts<<strtmp;
	
	fFile.close();
}

void C103Device::ProcessWave(WORD wNof, CString szFileName)
{
	CString sztmp = "", szcpuno = "", szgroup = "", szfun = "", szinf = "";
	szcpuno.sprintf("%d", (*it).CpuNo);
	szfun.sprintf("%d", -1);
	szinf.sprintf("%d", -1);
	QDomNode node, cnode;
	node = m_pxml->GetDomNode("body", "FAULT", "pcpuno", szcpuno);
	if (node.isNull()) return;
	if (!m_pxml->GetNodeAttr(node, "group", szgroup)) return;
	if (!m_pxml->GetNodeAttr(node, "cpuno", szcpuno)) return;
	cnode = m_pxml->GetChildNode(node, "ELEMENT", "pfun", szfun, "pinf", szinf);
	if (!cnode.isNull())
	{
		QFile Filefp(szFileName+".cfg");
		if (!Filefp.open(IO_ReadOnly)) return;
		
		sztmp = Filefp.name();
		int iyear = atoi(sztmp.left(4));
		int imonth = atoi(sztmp.mid(4, 2));
		int iday = atoi(sztmp.mid(6, 2));
		int ihour = atoi(sztmp.mid(8, 2));
		int iminute = atoi(sztmp.mid(10, 2));
		int isecond = atoi(sztmp.mid(12, 2));
		int imilliSecond = atoi(sztmp.mid(14, 3));
		QDateTime nowdatetime = QDateTime::currentDateTime();
			QDate nowdate = nowdatetime.date();
			QTime nowtime = nowdatetime.time();
		if (iyear < 1990 || iyear > nowdate.year() || iday < 1 || iday > 31 || imonth < 1 
			|| imonth > 12 || ihour < 0 || ihour > 24 || iminute < 0 || iminute > 60
			|| isecond < 0 || isecond > 60)
		{
			iyear = nowdate.year();
			imonth = nowdate.month();
			iday = nowdate.day();
			ihour = nowtime.hour();
			iminute = nowtime.minute();
			isecond = nowtime.second();
			imilliSecond = nowtime.msec();
		}
		st_fault* pRpt_Fault = new st_fault;
		st_faultact* pFaultAct = new st_faultact;
		memset(pRpt_Fault, 0x00, sizeof(st_fault));
		memset(pFaultAct, 0x00, sizeof(st_faultact));
		pRpt_Fault->m_StationNo = g_PublicClass.m_StationNo;
		pRpt_Fault->m_MachineNo = m_DevInfo.m_EquipNo;
		pRpt_Fault->m_CpuNo = szcpuno.toInt();
		pRpt_Fault->m_FaultNum = ++m_iFaultNo;
		strcpy(pRpt_Fault->m_MachineName, m_DevInfo.m_Equipment);
		strcpy(pRpt_Fault->m_WaveFile, szFileName.data());
		pRpt_Fault->m_HaveHdr = 1;
		pRpt_Fault->m_HaveCfg = 1;
		pRpt_Fault->m_HaveDat = 1;
		CString szDate = "";
		szDate.sprintf("%04d%02d%02d%02d%02d%02d%03d", iyear, imonth, iday, ihour, iminute,
					   isecond, imilliSecond);
		memcpy(pRpt_Fault->m_ActionTime, szDate.data(), szDate.length());
		
		pFaultAct->m_MachineNo = m_DevInfo.m_EquipNo;
		pFaultAct->m_CpuNo = szcpuno.toInt();
		pFaultAct->m_FaultNum = m_iFaultNo;
		m_pxml->GetNodeAttr(cnode, "desc", sztmp);
		memcpy(pFaultAct->m_ActElement, sztmp.data(), sztmp.length());
		pFaultAct->m_ActTime = 0;
		pFaultAct->m_Dpi = 2;
		m_pxml->GetNodeAttr(cnode, "fun", szfun);
		pFaultAct->m_FunCode = szfun.toInt();
		m_pxml->GetNodeAttr(cnode, "inf", szinf);
		pFaultAct->m_EventCode = szinf.toInt();
		pFaultAct->m_GroupNo = szgroup.toInt();
		m_pxml->GetNodeAttr(cnode, "entry", sztmp);
		pFaultAct->m_Entry = sztmp.toInt()