103device.cpp~

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

#include "103Device.h"
#include <qdatetime.h>
#include <time.h>
#include <qstringlist.h> 
#include <unistd.h>
#include <sys/types.h>
#include <qcstring.h> 
#include <qdir.h>

extern CPublicClass g_PublicClass;

C103Device::C103Device(st_deviceinfo DevInfo)
{
 memcpy(&m_DevInfo, &DevInfo, sizeof(st_deviceinfo));
 
 m_bCommError = false;
 m_bSendState3 = true;
 m_bSendState0 = true;
 m_bHaveL1UserData = false;
 m_bSwitch = false;
 
 m_FrameHead = 0x00;
 m_FrameLength = 0x00;
 m_ReceAddress = 0x00;
 m_FrameCS = 0x00;
 m_FrameEnd = 0x00;
 
 m_pComm = NULL;
 m_iThreadId = 0;
 
 m_iHaveWaveFile = 0;
 memset(&m_CmdInfo, 0x00, sizeof(st_nodeinfo));
 m_CmdInfo.m_MachineNo = m_DevInfo.m_EquipNo;
 
	m_szConFile = g_PublicClass.GetWorkPath()+"/devconfig/"+m_DevInfo.m_MachineType+".xml";
}

C103Device::~C103Device()
{
	m_ReceData.SetSize(0);
	m_CommParam.clear();
}

bool C103Device::InitClass()
{
	m_szSysPath = g_PublicClass.GetWorkPath()+"/data/"+m_DevInfo.m_Equipment+"/";
	mkdir(m_szSysPath, 0666);

	m_DistrubData.m_pXml = m_pxml;
	CString sztmp = "";
	QDomNode node, cnode;
	node = m_pxml->GetDomNode("body", "DEVCONFIG");
	if (node.isNull()) return false;
	
	cnode = m_pxml->GetChildNode(node, "NEEDDISTRUBT", "", "");
	if (!cnode.isNull())
	{
		m_pxml->GetNodeAttr(cnode, "value", sztmp);
		m_iWaveFlag = sztmp.toInt();
	}
	else m_iWaveFlag = 0;
	
	cnode = m_pxml->GetChildNode(node, "NEEDSAVEDATA", "", "");
	if (!cnode.isNull())
	{
		m_pxml->GetNodeAttr(cnode, "value", sztmp);
		m_iSaveFlag = sztmp.toInt();
	}
	else m_iSaveFlag = 0;
	
	cnode = m_pxml->GetChildNode(node, "TIMEOUT", "", "");
	if (!cnode.isNull())
	{
		m_pxml->GetNodeAttr(cnode, "value", sztmp);
		m_iTimesOut = sztmp.toInt();
	}
	else m_iTimesOut = 50;
	
	cnode = m_pxml->GetChildNode(node, "FIXTIME", "", "");
	if (!cnode.isNull())
	{
		m_pxml->GetNodeAttr(cnode, "value", sztmp);
		m_iFixTime = sztmp.toInt();
	}
	else m_iFixTime = 100;

	cnode = m_pxml->GetChildNode(node, "PRIMARY", "", "");
	if (!cnode.isNull())
	{
		m_pxml->GetNodeAttr(cnode, "value", sztmp);
		m_iPrimary = sztmp.toInt();
	}
	else m_iPrimary = 0;

	cnode = m_pxml->GetChildNode(node, "DPI1", "", "");
	if (!cnode.isNull())
	{
		m_pxml->GetNodeAttr(cnode, "value", m_szDpi1);
	}
	else m_szDpi1 = "复归";
	
	cnode = m_pxml->GetChildNode(node, "DPI2", "", "");
	if (!cnode.isNull())
	{
		m_pxml->GetNodeAttr(cnode, "value", m_szDpi2);
	}
	else m_szDpi2 = "动作";
	
	cnode = m_pxml->GetChildNode(node, "SDPI1", "", "");
	if (!cnode.isNull())
	{
		m_pxml->GetNodeAttr(cnode, "value", m_szSDpi1);
	}
	else m_szSDpi1 = "合";
	
	cnode = m_pxml->GetChildNode(node, "SDPI2", "", "");
	if (!cnode.isNull())
	{
		m_pxml->GetNodeAttr(cnode, "value", m_szSDpi2);
	}
	else m_szSDpi2 = "开";
	
	sztmp.sprintf("%s", m_DevInfo.m_Equipment);
	cnode = m_pxml->GetChildNode(node, "FAULTNO", "devname", sztmp);
	if (!cnode.isNull())
	{
		m_pxml->GetNodeAttr(cnode, "value", sztmp);
		m_iFaultNo = sztmp.toInt();
	}
	else
	{
		m_iFaultNo = 0;
		cnode = m_pxml->InsertChildNode(node, "FAULTNO");
		m_pxml->InsertNodeAttr(cnode, "devname", sztmp);
		m_pxml->InsertNodeAttr(cnode, "value", "0");
	}
	
	sztmp.sprintf("%s", m_DevInfo.m_Equipment);
	cnode = m_pxml->GetChildNode(node, "LASTWAVETIME", "devname", sztmp);
	if (!cnode.isNull())
	{
		m_pxml->GetNodeAttr(cnode, "value", m_szLastWaveTime);
	}
	else
	{
		m_szLastWaveTime = "00000000000000000";
		cnode = m_pxml->InsertChildNode(node, "LASTWAVETIME");
		m_pxml->InsertNodeAttr(cnode, "devname", sztmp);
		m_pxml->InsertNodeAttr(cnode, "value", "00000000000000000");
	}

	cnode = m_pxml->GetChildNode(node, "CPUNUM", "", "");
	if (!cnode.isNull())
	{
		m_pxml->GetNodeAttr(cnode, "value", sztmp);
		m_iCpuNum = sztmp.toInt();
	}
	else return false;

	for (int i=0; i<m_iCpuNum; i++)
	{
		CommParam CP;
		memset(&CP, 0x00, sizeof(CommParam));
		CP.SendAddress = m_DevInfo.m_EquipAddr+i;
		CP.AsduAddress = m_DevInfo.m_EquipAddr+i;
		CP.CpuNo = i+1;
		sztmp.sprintf("CPU%dFUNCODE", i+1);
		cnode = m_pxml->GetChildNode(node, sztmp, "", "");
		if (!cnode.isNull())
		{
			m_pxml->GetNodeAttr(cnode, "value", sztmp);
			CP.FunCode = sztmp.toInt();
		}
		else return false;
		CP.bInit = false;
		CP.bLinkStatus = false;
		CP.bLinkBusy = true;
		m_CommParam.append(CP);
	}

	it = m_CommParam.at(0);//为什么要赋值
	
	node = m_pxml->GetDomNode("body", "WAVCONFIG");
	if (!node.isNull())
	{
		cnode = m_pxml->GetChildNode(node, "TYPE", "", "");
		if (!cnode.isNull())
		{
			m_pxml->GetNodeAttr(cnode, "value", sztmp);
			m_iWavType = sztmp.toInt();
		}
		else m_iWavType = 0;
	}
	else m_iWavType = 0;
	
	m_GITime = QDateTime::currentDateTime();
	return true;
}

BYTE C103Device::CalCheckSum(const CByteArray& Data, bool bSend /* = false */)
{
	int iSize = Data.GetSize();
	BYTE CheckSum = 0;
	
	if (bSend)
	{
		CheckSum += (*it).CCD.byte;
		CheckSum += (*it).SendAddress;
	}
	else
	{
		CheckSum += (*it).DCD.byte;
		CheckSum += m_ReceAddress;
	}
	for (int i=0; i<iSize; i++)
		CheckSum += Data.GetAt(i);
	return CheckSum;
}

bool C103Device::SendData(CByteArray& sData)
{
	int iSendSum = sData.GetSize();
	CByteArray Data;
	if (iSendSum > 0)
	{
		Data.SetSize(iSendSum+8);
		Data.SetAt(0, 0x68);
		Data.SetAt(1, (BYTE)iSendSum+2);
		Data.SetAt(2, (BYTE)iSendSum+2);
		Data.SetAt(3, 0x68);
		Data.SetAt(4, (*it).CCD.byte);
		Data.SetAt(5, (*it).SendAddress);
		memcpy(&Data[6], sData.GetData(), iSendSum);
		Data.SetAt(6+iSendSum, CalCheckSum(sData, true));
		Data.SetAt(7+iSendSum, 0x16);
	}
	else
	{
		Data.SetSize(5);
		Data.SetAt(0, 0x10);
		Data.SetAt(1, (*it).CCD.byte);
		Data.SetAt(2, (*it).SendAddress);
		Data.SetAt(3, CalCheckSum(sData, true));
		Data.SetAt(4, 0x16);
	}
	iSendSum = Data.GetSize();
	if (!m_pComm->SendData(Data.GetData(), iSendSum, 10))
	{
		m_bCommError = true;	
		return false;
	}
	//add by HYK for debug
	//printData("Send data:",Data.GetData(),Data.GetSize());
	//add end
	if (g_PublicClass.m_MonitorData.m_MachineNo == (int)m_DevInfo.m_EquipNo)//送给自己
	{
		if (g_PublicClass.m_MonitorData.m_SrcFlag == 2 || g_PublicClass.m_MonitorData.m_SrcFlag == 3)
		{
			CDataNode* pNode = new CDataNode();
			BYTE* pData = new BYTE[Data.GetSize()];
			memcpy(pData, Data.GetData(), Data.GetSize());
			memcpy(&pNode->m_nodeinfo, &m_CmdInfo, sizeof(st_nodeinfo));
			pNode->m_nodeinfo.mtype = g_PublicClass.m_MainModuleNode.m_deviceinfo.mtype;
			pNode->m_nodeinfo.requestid = g_PublicClass.m_SelfPid;
			pNode->m_nodeinfo.m_iResult = 1;
			pNode->m_nodeinfo.m_SegmentPid = (long)pData;
			pNode->m_nodeinfo.m_iSize = Data.GetSize();
			pNode->m_nodeinfo.m_DataType = DATA_SENDDATA;
			g_PublicClass.m_NodeManage.AddDispDataNode((void*)pNode);
		}
	}
	Data.SetSize(0);
	usleep(m_iTimesOut);
	return true;
}

bool C103Device::ReceData(CByteArray& rData)
{
	int iReadSum = 1;
	BYTE btmp = 0;
	if (!m_pComm->RecvData(&btmp, iReadSum, 10))
	{
		m_bCommError = true;
		m_bHaveL1UserData = false;
		return false;
	}
	if (iReadSum > 0) m_FrameHead = btmp;
	else
	{
		(*it).bInit = false;
		m_bHaveL1UserData = false;
		return false;
	}
	if (m_FrameHead == 0x68)//可变长帧
	{
		iReadSum = 5;
		rData.SetSize(iReadSum);
		if (!m_pComm->RecvData(rData.GetData(), iReadSum, 10))
		{
			m_bCommError = true;
			m_bHaveL1UserData = false;
			return false;
		}
		if (rData.GetAt(0) == rData.GetAt(1)) m_FrameLength = rData.GetAt(0);
		else
		{
			m_bHaveL1UserData = false;
			return false;
		}
		if (rData.GetAt(2) != m_FrameHead)
		{
			m_bHaveL1UserData = false;
			return false;
		}
		(*it).DCD.byte = rData.GetAt(3);	
		m_ReceAddress = rData.GetAt(4);
		if ((*it).DCD.DevToCtrl.ACD == 1) m_bHaveL1UserData = true;
		else m_bHaveL1UserData = false;
		if (m_ReceAddress != (*it).SendAddress)
		{
			m_bHaveL1UserData = false;
			return false;
		}
		rData.SetSize(0);	
		rData.SetSize(m_FrameLength-2);
		iReadSum = m_FrameLength-2;
		if (!m_pComm->RecvData(rData.GetData(), iReadSum, 10))
		{
			m_bCommError = true;
			m_bHaveL1UserData = false;
			return false;
		}
		iReadSum = 1;
		if (!m_pComm->RecvData(&m_FrameCS, iReadSum, 10))
		{
			m_bCommError = true;
			m_bHaveL1UserData = false;
			return false;
		}
		iReadSum = 1;
		if (!m_pComm->RecvData(&m_FrameEnd, iReadSum, 10))
		{
			m_bCommError = true;
			m_bHaveL1UserData = false;
			return false;
		}
		if (m_FrameEnd != 0x16)
		{
			m_bHaveL1UserData = false;
			return false;
		}
		if (m_FrameCS != CalCheckSum(rData))
		{
			m_bHaveL1UserData = false;
			return false;
		}
	}
	else if (m_FrameHead == 0x10)//固定长帧
	{
		iReadSum = 4;	
		rData.SetSize(iReadSum);
		if (!m_pComm->RecvData(rData.GetData(), iReadSum, 10))
		{
			m_bCommError = true;
			m_bHaveL1UserData = false;
			return false;
		}
		
		(*it).DCD.byte	= rData.GetAt(0);
		m_ReceAddress	= rData.GetAt(1);
		m_FrameCS		= rData.GetAt(2);
		m_FrameEnd		= rData.GetAt(3);
		
		if (m_FrameEnd != 0x16)
		{
			m_bHaveL1UserData = false;
			return false;
		}
		if (m_ReceAddress != (*it).SendAddress)
		{
			m_bHaveL1UserData = false;
			return false;
		}
		if ((*it).DCD.DevToCtrl.ACD == 1) m_bHaveL1UserData = true;
		else m_bHaveL1UserData = false;
		if ((*it).DCD.DevToCtrl.FunCode == 1) (*it).bLinkBusy = true;
		else (*it).bLinkBusy = false;
		
		rData.SetSize(0);
		if (m_FrameCS != CalCheckSum(rData))
		{
			m_bHaveL1UserData = false;
			return false;
		}
	}
	else if (m_FrameHead == 0xE5)
	{
		m_bHaveL1UserData = false;
		return true;
	}
	else 
	{
		m_bHaveL1UserData = false;
		iReadSum = 300;
		CByteArray tData;
		tData.SetSize(iReadSum);
		tData.SetAt(0, btmp);
		if (!m_pComm->RecvData(tData.GetData()+1, iReadSum, 10))
		{
			m_bCommError = true;
			m_bHaveL1UserData = false;
			return false;
		}
		tData.SetSize(0);
		return false;
	}
	
	if (g_PublicClass.m_MonitorData.m_MachineNo == (int)m_DevInfo.m_EquipNo)//送给自己
	{
		if (g_PublicClass.m_MonitorData.m_SrcFlag == 1 || g_PublicClass.m_MonitorData.m_SrcFlag == 3)
		{
			BYTE* pData = NULL;
			int iLen = 0;
			if (m_FrameHead == 0x10)
			{
				pData = new BYTE[5];
				iLen = 5;
				pData[0] = m_FrameHead;
				pData[1] = (*it).DCD.byte;
				pData[2] = m_ReceAddress;
				pData[3] = m_FrameCS;
				pData[4] = m_FrameEnd;
			}
			else 
			{
				pData = new BYTE[8+rData.GetSize()];
				iLen = 8+rData.GetSize();
				pData[0] = m_FrameHead;
				pData[1] = m_FrameLength;
				pData[2] = m_FrameLength;
				pData[3] = m_FrameHead;
				pData[4] = (*it).DCD.byte;
				pData[5] = m_ReceAddress;
				memcpy(&pData[6], rData.GetData(), rData.GetSize());
				pData[6+rData.GetSize()] = m_FrameCS;
				pData[7+rData.GetSize()] = m_FrameEnd;
			}
			CDataNode* pNode = new CDataNode();
			memcpy(&pNode->m_nodeinfo, &m_CmdInfo, sizeof(st_nodeinfo));
			pNode->m_nodeinfo.mtype = g_PublicClass.m_MainModuleNode.m_deviceinfo.mtype;
			pNode->m_nodeinfo.requestid = g_PublicClass.m_SelfPid;
			pNode->m_nodeinfo.m_iResult = 1;
			pNode->m_nodeinfo.m_SegmentPid = (long)pData;
			pNode->m_nodeinfo.m_iSize = iLen;
			pNode->m_nodeinfo.m_DataType = DATA_RECVDATA;
			g_PublicClass.m_NodeManage.AddDispDataNode((void*)pNode);
			
			//add by HYK for debug
			//printData("Send data:",pData,iLen);
			//add end
		}
	}
	
	return true;
}

bool C103Device::RequestLinkStatus()
{
	CByteArray Data;
	(*it).CCD.byte = 0x09;
	
	Data.SetSize(0);
	if (SendData(Data))