signalprocess-bak.cpp

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

//signalprocess.cpp
#include "signalprocess.h"
#include "devmoduledlg.h"
#include "Device.h"
#include <qtabwidget.h> 
#include <qtextbrowser.h> 
#include "baseclass/publicclass.h"

extern CPublicClass g_PublicClass;

////////////////////////////////////////////设备启动方案///////////////////////////////////////////
/*
主模块传送来的是一个结构数组:st_deviceinfo[count]
1.先找出ParentIndex=""的设备,这种设备是独立的或是总线,管理机,启动这些设备的线程,
  并产生设备的接点,接点中:m_deviceinfo存放当前设备信息.
2.按照设备接点在结构数组中查找:ParentIndex=当前接点的RecordIndex的设备,这些设备
  是总线或管理机下的设备,这些设备的信息添加到接点中的:m_ChildDevList中,并填入线
  程号
3.简单地说就是独立设备产生一个接点,其m_ChildDevList为空,每个总线或管理机产生一
  个接点,其m_ChildDevList中存放其下级设备
*/
/////////////////////////////////////////////////////////////////////////////////////////////////////

CSystemInit::CSystemInit()
{
}

CSystemInit::~CSystemInit()
{  
}

void CSystemInit::SendMsgTextToMain(int flag, QString sMsg)
{
    QDateTime t = QDateTime::currentDateTime();
    QString s1 = "";
    s1 = "["+t.toString("yyyy-MM-dd hh:mm:ss")+"]:";
    s1 = s1+_T(sMsg);
    ((DevModuleDlg*)g_PublicClass.m_MainForm)->SetLogText(flag, s1);
}

bool CSystemInit::StartDevices(void* ppNode)
{
    CDataNode* pNode = (CDataNode*)ppNode;
    if (!pNode) return false;
    int count = pNode->m_nodeinfo.m_iSize/sizeof(st_deviceinfo);
    st_deviceinfo dst[count];
    memcpy(&dst, (void*)pNode->m_nodeinfo.m_SegmentPid, pNode->m_nodeinfo.m_iSize);
    //启动一级保护通讯线程
    for (int i=0; i<count; i++)
    {
    	AddOneP2pDevice(dst+i);
    }
    StartSomeTopDevice();
    
    return true;
}

bool CSystemInit::AddOneP2pDevice(void *pNode)
{	
	if (pNode == NULL) return false;
	st_deviceinfo DevBuff;
	memcpy(&DevBuff, pNode, sizeof(st_deviceinfo));
	//判断是否是总线或管理机
	if (DevBuff.m_ParentIndex[0] != '\0') return 0;
	if (DevBuff.m_EquipNo == 0) return 0;
	CDeviceNode* pParentNode = NULL;
	if (g_PublicClass.m_NodeManage.m_DeviceNode.count() <= 0)
	{
		pParentNode = new CDeviceNode();
		memset(&(pParentNode->m_deviceinfo), 0x00, sizeof(st_deviceinfo));
		memcpy(&(pParentNode->m_deviceinfo), &DevBuff, sizeof(st_deviceinfo));
		pParentNode->m_deviceinfo.m_UsedIp = 1;
                pParentNode->m_deviceinfo.m_EquipNo = 0;
		pParentNode->m_ModuleState = 0;
		pParentNode->m_Level = 0;
                memset(pParentNode->m_deviceinfo.m_Equipment, 
                        0x00, sizeof(pParentNode->m_deviceinfo.m_Equipment));
                strcpy(pParentNode->m_deviceinfo.m_Equipment, "CSC LAN");
                memset(pParentNode->m_deviceinfo.m_RecordIndex, 
                        0x00, sizeof(pParentNode->m_deviceinfo.m_RecordIndex));
		strcpy(pParentNode->m_deviceinfo.m_RecordIndex, "linux19760521");
		g_PublicClass.m_NodeManage.m_DeviceNode.append(pParentNode);
	}
	//按设备编号查找
	int index = 0;
	pthread_t threadid = 0;
	pParentNode = g_PublicClass.m_NodeManage.FindDevicebyEquipNo(0, 0, index);
	if (pParentNode)
	{
		CDeviceNode *pChildNode = NULL;
		pChildNode = g_PublicClass.
                    m_NodeManage.FindDevicebyEquipNo(DevBuff.m_EquipNo, 1, index);
		if (!pChildNode)
		{
			pParentNode->AddChildDevices(pNode, 1, threadid);
		}	
	}
	
	return true;
}

bool CSystemInit::StartSomeTopDevice()
{
	CDeviceNode* pDevNode = NULL;
	//按设备编号查找
	int index = 0, ret = 0;
	pthread_t threadid = 0;
	//查找虚拟父结点（根据m_Level来查找）
	pDevNode = g_PublicClass.m_NodeManage.FindDevicebyEquipNo(0, 0, index);
	if (pDevNode)
	{
		ret = pthread_create(&threadid, NULL, DeviceCommunicateMainThread, pDevNode);
		pDevNode->m_deviceinfo.m_ThreadId = threadid;//线程号付给接点线程号
		pDevNode->m_deviceinfo.m_SupportCmd = InstallDeviceMenu(pDevNode);
		st_deviceinfo DevSt;
		memcpy(&DevSt, &(pDevNode->m_deviceinfo), sizeof(DevSt));
		pDevNode->UpdateChildDevicesThread(&DevSt, sizeof(DevSt));
		pDevNode->m_ModuleState = 1;
		//产生发送数据接点
		int count = (int)pDevNode->m_ChildDevList.count();
		st_deviceinfo di[1+count];
		memcpy(&di[0], &pDevNode->m_deviceinfo, sizeof(st_deviceinfo));
		if (count > 0)
                {
		    DeviceInfoListType::iterator it;
		    for (int i=0; i<count; i++)
                    {
                        it = pDevNode->m_ChildDevList.at(i);
                        memcpy(&di[1+i], &(*it), sizeof(st_deviceinfo));
                         di[0].m_ThreadId = 1111;
                    }
                }
      	        g_PublicClass.m_NodeManage.AddSendDataNode(
      		    g_PublicClass.m_MainModuleNode.m_deviceinfo.mtype, 
         	    0, WM_SENDDEVTHREADID,(void*)&di, 
         	    (1+count)*sizeof(st_deviceinfo));
		//设备加入界面
		((DevModuleDlg*)g_PublicClass.m_MainForm)->AddTopLevelDevice(
                                                                        (void*)pDevNode);
		((DevModuleDlg*)g_PublicClass.m_MainForm)->AddChildDevice(
                                                                        (void*)pDevNode);
    }
    else//failed
    {
	return false;
    }
    return true;
}
//////////////////////////启动设备列表中的独立或顶级设备线程//////////////////////////////////
int CSystemInit::StartSomeTopDevice(void* dlist, int pi, int count)
{
	CDeviceNode* pNode = NULL;
	st_deviceinfo DevBuff;
	memcpy(&DevBuff, (char*)dlist+pi*sizeof(st_deviceinfo), sizeof(st_deviceinfo));
	//判断是否是总线或管理机
	if (DevBuff.m_ParentIndex[0] != '\0') return 0;
	//按设备编号查找
	int index = 0, ret = 0;
	pthread_t threadid = 0;
	pNode = g_PublicClass.m_NodeManage.FindDevicebyEquipNo(DevBuff.m_EquipNo, 0, index);
	if (!pNode)
	{
		//产生顶级设备接点
		pNode = new CDeviceNode();
		pNode->m_ModuleState = 0;
		pNode->m_Level = 0;
		memcpy(&pNode->m_deviceinfo, &DevBuff, sizeof(st_deviceinfo));
		g_PublicClass.m_NodeManage.m_DeviceNode.append(pNode);	
		//启动设备通讯线程
		usleep(1);
		ret = pthread_create(&threadid, NULL, DeviceCommunicateMainThread, pNode);
		pNode->m_deviceinfo.m_ThreadId = threadid;//线程号付给接点线程号
		pNode->AddChildDevices(dlist, count, threadid);
		pNode->m_deviceinfo.m_SupportCmd = InstallDeviceMenu(pNode);
		//当是点对点通信时,也考虑成总线方式,只不过该总线下只有一个设备而已
		if (pNode->m_ChildDevList.count() == 0)
		{
			pNode->m_ChildDevList.append(pNode->m_deviceinfo);
		}
		pNode->m_ModuleState = 1;
		//产生发送数据接点
		st_deviceinfo di[1+pNode->m_ChildDevList.count()];
		memcpy(&di[0], &pNode->m_deviceinfo, sizeof(st_deviceinfo));
		if ((int)pNode->m_ChildDevList.count() > 0)
		{
			DeviceInfoListType::iterator it;
			for (int i=0; i<(int)pNode->m_ChildDevList.count(); i++)
			{
				it = pNode->m_ChildDevList.at(i);
				memcpy(&di[1+i], &(*it), sizeof(st_deviceinfo));
			}
		}
		g_PublicClass.m_NodeManage.AddSendDataNode(
			g_PublicClass.m_MainModuleNode.m_deviceinfo.mtype, 0, WM_SENDDEVTHREADID,
			(void*)&di, (1+pNode->m_ChildDevList.count())*sizeof(st_deviceinfo));	
		//设备加入界面
		((DevModuleDlg*)g_PublicClass.m_MainForm)->AddTopLevelDevice((void*)pNode);
		((DevModuleDlg*)g_PublicClass.m_MainForm)->AddChildDevice((void*)pNode);
    }
	else//总线设备已经启动,现有新的设备启动
	{
		CDeviceNode* pDevNode = NULL;
		st_deviceinfo Dev;
		for (int i=0; i<count; i++)
		{
			memcpy(&Dev, (char*)dlist+i*sizeof(st_deviceinfo), sizeof(st_deviceinfo));
			if (Dev.m_ParentIndex[0] == '\0') continue;
			if (QString(Dev.m_ParentIndex) != QString(pNode->m_deviceinfo.m_RecordIndex)) continue;
			pDevNode = g_PublicClass.m_NodeManage.FindDevicebyEquipNo(Dev.m_EquipNo, 1, index);
			if (!pDevNode)//在设备列表中添加该设备
			{				
				st_nodeinfo st;
				memset(&st, 0x00, sizeof(st_nodeinfo));
				st.m_CurrentThread = pNode->m_deviceinfo.m_ThreadId;
				st.m_MachineNo = Dev.m_EquipNo;
				st.m_DataType = WM_RUN_A_DEVICE;//设备启动命令
				st_deviceinfo* pDev = new st_deviceinfo;
				memcpy(pDev, &Dev, sizeof(st_deviceinfo));
				st.m_SegmentPid = (long)pDev;
				st.m_iSize = sizeof(st_deviceinfo);
				CDataNode* pMsgNode = new CDataNode();
				memcpy(&pMsgNode->m_nodeinfo, &st, sizeof(st_nodeinfo));
				g_PublicClass.m_NodeManage.m_RecvNode.append(pMsgNode);
			}
		}
	}
    return 1;
}
//******************安装设备操作菜单的函数**************************//
//*从XML文件中读取菜单	
int CSystemInit::InstallDeviceMenu(CDeviceNode* pNode)
{
	return 9511;
	/*
    DeviceInfoListType::iterator it;
    QString xmlfile;
	QDomNode node, cnode;
	for (int i=0; i<(int)pNode->m_ChildDevList.count(); i++)
	{
		it = pNode->m_ChildDevList.at(i);
		xmlfile.sprintf("%s", (*it).m_MachineType);
		if (xmlfile == "" || xmlfile.isEmpty()) continue;
		xmlfile = g_PublicClass.GetWorkPath()+"/devconfig/"+xmlfile+".xml";
		CXMLReader xml(xmlfile);
		xml.OpenDomXMLFile();
		node = xml.GetDomNode("body", "CONFIG");
		cnode  = xml.GetChildNode(node, "MENU", "", "");
		QString sztmp = "";
		xml.GetNodeAttr(cnode, "value", sztmp);
		(*it).m_SupportCmd = sztmp.toInt();
	}
	xmlfile.sprintf("%s", pNode->m_deviceinfo.m_MachineType);
	if (xmlfile == "" || xmlfile.isEmpty()) return 0;
	xmlfile = g_PublicClass.GetWorkPath()+"/devconfig/"+xmlfile+".xml";
	CXMLReader xml(xmlfile);
	xml.OpenDomXMLFile();
	node = xml.GetDomNode("body", "CONFIG");
	cnode = xml.GetChildNode(node, "MENU", "", "");
	QString sztmp = "";
	xml.GetNodeAttr(cnode, "value", sztmp);
	return sztmp.toInt();*/
}

void SignalProcessDef1x(int signum, siginfo_t* info, void* myact)
{
    CSystemInit csi;
    QString s1 = "";
    if (signum == 0 || !info || !myact) return;
	if (info->si_int >= 0) //主模块送的是消息队列号
	{
		s1.sprintf("收到主模块发送队列号:%d;接收队列号:%d", g_PublicClass.m_SendMsgQueueID, g_PublicClass.m_ReceMsgQueueID);
	}
	else if (info->si_int < 0)//主模块的测试信号
	{
		((DevModuleDlg*)g_PublicClass.m_MainForm)->FlashLamp();
		g_PublicClass.m_MainModuleNode.m_LastTime = QDateTime::currentDateTime();
		g_PublicClass.m_Signal.SendSignal(info->si_pid, SIGUSR1, 0, NULL, 0);
		s1.sprintf("收到主模块测试信号:%d", info->si_pid);
    }
    csi.SendMsgTextToMain(0, s1);
    return;
}

void SignalProcessDef2x(int signum, siginfo_t* info, void* myact)
{
    if (signum == 0 || !info || !myact) return;
    return;
}


/////////////////////////////////////常驻接收信息线程//////////////////////////////////////
void* RecvMsgQueueThread(void* lp)
{
    lp = NULL;
    CMessageQueue cm;
	st_nodeinfo st;
	CSegment cs;
    while (!g_PublicClass.m_Stop)
    {
		//当没有收到消息号时,等待
		if (g_PublicClass.m_ReceMsgQueueID == 0) 
		{
			usleep(100);
			continue;
		}
		if (!cm.ReadMessage(g_PublicClass.m_ReceMsgQueueID, g_PublicClass.m_SelfPid, &st))
		{
			usleep(100);
			continue;
		}
		CDataNode* pNode = new CDataNode();
		memcpy(&pNode->m_nodeinfo, &st, sizeof(st_nodeinfo));
		g_PublicClass.m_NodeManage.m_RecvNode.append(pNode);
		usleep(10);
    }
    return NULL;
}

/////////////////////////////////////常驻发送信息线程//////////////////////////////////////
void* SendMsgQueueThread(void* lp)
{
    lp = NULL;
    CMessageQueue cm;
	CSegment cs;
    CDataNode* pNode = NULL;
    while (!g_PublicClass.m_Stop)
    {
		//当发送队列没有形成时,等待
		if (g_PublicClass.m_SendMsgQueueID == 0) 
		{
			usleep(10);
			continue;
		}
		pNode = g_PublicClass.m_NodeManage.FindSendDataNode();
		if (!pNode)
		{
			usleep(10);
			continue;
		}	
		if (pNode->m_nodeinfo.m_DataType == WM_STOP_A_MODULE)
		{
			g_PublicClass.m_Stop = true;
			sleep(2);
		}
		
		cm.SendMessage(g_PublicClass.m_SendMsgQueueID, (void*)pNode);
		//删除数据接点
		g_PublicClass.m_NodeManage.DeleteSendDataNode(pNode);
		usleep(10);
    }
    return NULL;
}

////////////////////////////////////常驻处理接收信息线程//////////////////////////////////////
void* ProcessRecvMsgThread(void* lp)
{
    lp = NULL;
    CDataNode* pNode = NULL;
	CSystemInit csi;
    while (!g_PublicClass.m_Stop)
    {
		pNode = g_PublicClass.m_NodeManage.FindRecvDataNode(0);
		if (!pNode)
		{
			usleep(10);
			continue;
		}
		switch (pNode->m_nodeinfo.m_DataType)
		{
		case WM_STARTDEVICETHREAD://启动设备线程
			csi.StartDevices((void*)pNode);
		//	printf("--@@Csc103 start device @@--\n");
			break;
		case WM_MONITORSET:
			if (pNode->m_nodeinfo.m_SegmentPid > 0 && pNode->m_nodeinfo.m_iSize > 0)
			{
				memcpy(&g_PublicClass.m_MonitorSrc, (char*)pNode->m_nodeinfo.m_SegmentPid, sizeof(st_monitorsrc));
			}
			break;
		}
		//删除数据接点
		g_PublicClass.m_NodeManage.DeleteRecvDataNode(pNode);
    }
    return NULL;
}

void* DispDataThread(void* lp)
{
	lp = NULL;
	while (g_PublicClass.m_MainForm == NULL) usleep(100);
	CDataNode* pNode = NULL;
	DevModuleDlg* pDlg = (DevModuleDlg*)g_PublicClass.m_MainForm;
	QTextBrowser* pBrower = NULL;
	
    while (!g_PublicClass.m_Stop)
    {
		pNode = g_PublicClass.m_NodeManage.FindDispDataNode();
		if (pNode)
		{
			QString dispstr = "", tmpstr = "";
			uchar* pData = (uchar*)pNode->m_nodeinfo.m_SegmentPid;
			int iSize = pNode->m_nodeinfo.m_iSize;
			QDateTime dt = QDateTime::currentDateTime();
			if (pNode->m_nodeinfo.m_DataType == DATA_SENDDATA)
			{
				tmpstr.sprintf("[%s]-Send:%d Dev:%d", dt.toString("yyyy-MM-dd-hh:mm:ss.zzz").data(), iSize, pNode->m_nodeinfo.m_MachineNo);
				pBrower = (QTextBrowser*)pDlg->GetTextBrower(2);
			}
			else if (pNode->m_nodeinfo.m_DataType == DATA_RECVDATA)
			{
				tmpstr.sprintf("[%s]-Recv:%d Dev:%d", dt.toString("yyyy-MM-dd-hh:mm:ss.zzz").data(), iSize, pNode->m_nodeinfo.m_MachineNo);
				pBrower = (QTextBrowser*)pDlg->GetTextBrower(1);
			}
			pBrower->setColor(QColor::QColor(255,0,0));
			pBrower->append(tmpstr);
			for (int i=0; i<iSize; i++)
			{
				tmpstr.sprintf("%02X ", pData[i]);
				dispstr += tmpstr;
			}
			pBrower->setColor(QColor::QColor(0,0,255));
			pBrower->append(dispstr);
			if (pBrower->lines() > 1000) pBrower->clear();
			g_PublicClass.m_NodeManage.DeleteDispDataNode(pNode);
			usleep(10);
			continue;
		}
		usleep(100);
    }
    return NULL;
}