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))