allmgr.h

一个通讯管理机的源代码。比较好用。推荐

#ifndef ALLMGR_H
#define ALLMGR_H
/**
  *@author 
  */
#include "msystem.h"
#include "appservice.h"
#include "monitorsvr.h"

#ifdef _MYSAL_
#include "mysal.h"
#endif

#include "ycset.h"
#include "yxset.h"
#include "wdog.h"
#include "modbustcp.h"
#include "monitortcpslave.h"	

class CAnalog {
public:
	CAnalog(WORD wDevNo,WORD wLocalNo,float fCoef)
	{
		m_dwYCNo = (DWORD)wDevNo*1000 + wLocalNo;
		if (fCoef == 0) fCoef = 1;
		m_fCoef = fCoef;
		m_fTHV = 0.005f;
		m_fFLT = 0;
		m_bIV = true;
		m_bNT = true;
		m_bBL = false;
		m_fValue = 0.0f;
	}
	CAnalog(DWORD dwYCNo)
	{
		m_dwYCNo = dwYCNo;
	}
	double GetValue(bool bPrmValue = true)
	{
		double fRet;
		if (bPrmValue) fRet = m_fValue;
		else fRet = m_fValue/m_fCoef;
		m_bNT = true;
		return fRet;
	}
	
	DWORD GetYCNo() const
	{
		return m_dwYCNo;
	}
	void SetYCNo(WORD wDevNo,WORD wLocalNo)
	{
		m_dwYCNo = (DWORD)wDevNo*1000 + wLocalNo;
	}
	void SetCoef(float fCoef)
	{
		m_fCoef = fCoef;
	}
	bool operator<(const CAnalog& a) const
	{
		bool bRet = false;
		if (m_dwYCNo < a.m_dwYCNo)
			bRet = true;
		return bRet;
	}
	bool operator>(const CAnalog& a) const
	{
		bool bRet = false;
		if (m_dwYCNo < a.m_dwYCNo)
			bRet = true;
		return bRet;
	}
	bool operator==(const CAnalog& a) const
	{
		bool bRet = false;
		if (m_dwYCNo == a.m_dwYCNo)
			bRet = true;
		return bRet;
	}
	bool operator!=(const CAnalog& a) const
	{
		bool bRet = false;
		if (m_dwYCNo != a.m_dwYCNo)
			bRet = true;
		return bRet;
	}
	void SetValue(double fValue)
	{
		if (!m_bBL)
		{
			double fTemp = fValue*m_fCoef;
			if (m_bIV)
			{
				m_fValue = fTemp;
				m_bIV = false;
				m_bNT = false;
			}
			else
			{
				double fOldValue = m_fValue;
				m_fValue = fTemp + m_fFLT*(m_fValue-fTemp);
				if (m_fValue > fOldValue)
				{
					if (m_fValue - fOldValue > m_fTHV)
						m_bNT = false;
				}
				else if (fOldValue -m_fValue > m_fTHV)
					m_bNT = false;
			}
		}
	}
	bool IsValid() {return !m_bIV;}
	bool GetNT() {return m_bNT;}
	void SetNT() {m_bNT = true;}
	CAnalog* GetThis(){return this;}
protected:
	DWORD m_dwYCNo; //devno*1000+localno
	float	m_fCoef;
	double	m_fValue;
	bool	m_bBL;//=1:被封锁
	bool	m_bSB;//=1:被取代
	bool	m_bIV;//=1:无效
	bool	m_bNT;//=1:非当前值

	float	m_fTHV;//门限值
	float	m_fFLT;//滤波系数
	float	m_fLLMT;//低限值
	float	m_fHLMT;//高限值
};

class CAnalogs
{
public:
	CAnalogs()
	{
		Load();
	}
	CAnalog* GetAnalog(DWORD dwYCNo)
	{
		CAnalog* pAnalog = (CAnalog *)NULL;
		vector<CAnalog>::iterator pa;
		CAnalog a(dwYCNo);
		pa = lower_bound(m_vAnalog.begin(),m_vAnalog.end(),a);
		if ((pa !=m_vAnalog.end()) && (pa->GetYCNo() == dwYCNo))
			pAnalog = pa->GetThis();
		return pAnalog;
		
	}
	void Load();
	DWORD GetSize() {return m_vAnalog.size();}
	void GetAll(YCData* pbyData,int& nSize)
	{
		vector<CAnalog>::iterator pa = m_vAnalog.begin();
		YCData* pTemp = (YCData *)pbyData;
		nSize = 0;
		for (;pa !=m_vAnalog.end();pa++)
		{
			if (pa->IsValid())
			{
				pTemp->m_wDevNo = pa->GetYCNo() / 1000;
				pTemp->m_wDevPtNo = pa->GetYCNo() % 1000;
				pTemp->m_fValue = pa->GetValue();
				nSize += sizeof(YCData);
				pTemp++;
			}
		}
	}
	void GetAllChanged(YCData* pbyData,int& nSize)
	{
		vector<CAnalog>::iterator pa = m_vAnalog.begin();
		YCData* pTemp = (YCData *)pbyData;
		nSize = 0;
		for (;pa !=m_vAnalog.end();pa++)
		{
			if (!pa->GetNT())
			{
				pTemp->m_wDevNo = pa->GetYCNo() / 1000;
				pTemp->m_wDevPtNo = pa->GetYCNo() % 1000;
				pTemp->m_fValue = pa->GetValue();
			//	printf("[%d][%d][%f]\n",pTemp->m_wDevNo,pTemp->m_wDevPtNo,pTemp->m_fValue);
				nSize += sizeof(YCData);
				pTemp++;
			}
		}
	}
protected:
	vector<CAnalog> m_vAnalog;
};

class CDigital {
public:
	CDigital(WORD wDevNo,WORD wLocalNo,bool bNOT)
	{
		m_dwYXNo = (DWORD)wDevNo*1000 + wLocalNo;
		m_bNOT = bNOT;
		m_bIV = true;
		m_bNT = true;
		m_bBL = false;
		m_bValue = false;
	}
	CDigital(DWORD dwYXNo)
	{
		m_dwYXNo = dwYXNo;
	}
	bool GetValue()
	{
		bool bRet;
		bRet = m_bValue;
		m_bNT = true;
		return bRet;
	}
	DWORD GetYXNo()
	{
		return m_dwYXNo;
	}
	void SetYXNo(WORD wDevNo,WORD wLocalNo)
	{
		m_dwYXNo = (DWORD)wDevNo*1000 + wLocalNo;
	}
	void SetNOT(bool bNOT = true)
	{
		m_bNOT = bNOT;
	}
	bool operator<(const CDigital& a) const
	{
		bool bRet = false;
		if (m_dwYXNo < a.m_dwYXNo)
			bRet = true;
		return bRet;
	}
	bool operator>(const CDigital& a) const
	{
		bool bRet = false;
		if (m_dwYXNo < a.m_dwYXNo)
			bRet = true;
		return bRet;
	}
	bool operator==(const CDigital& a) const
	{
		bool bRet = false;
		if (m_dwYXNo == a.m_dwYXNo)
			bRet = true;
		return bRet;
	}
	bool operator!=(const CDigital& a) const
	{
		bool bRet = false;
		if (m_dwYXNo != a.m_dwYXNo)
			bRet = true;
		return bRet;
	}
	void SetValue(bool bValue)
	{
		if (!m_bBL)
		{
			bool bTemp = /*m_bNOT? !bValue :*/ bValue;
			if (m_bIV)
			{
				m_bValue = bTemp;
				m_bIV = false;
				m_bNT = false;
			}
			else if (m_bValue != bTemp)
			{
				m_bValue = bTemp;
				m_bNT = false;
			}
		}
	}
	bool IsValid() {return !m_bIV;}
	bool GetNT() {return m_bNT;}
	void SetNT() {m_bNT = true;}
	CDigital* GetThis(){return this;}
protected:
	DWORD m_dwYXNo; //devno*1000+localno
	bool	m_bNOT;
	bool	m_bValue;
	bool	m_bBL;//=1:被封锁
	bool	m_bIV;//=1:无效
	bool	m_bSB;//=1:被取代
	bool	m_bNT;//=1:非当前值
};

class CDigitals
{
public:
	CDigitals()
	{
		Load();
	}
	CDigital* GetDigital(DWORD dwYXNo)
	{
		CDigital* pDigital = NULL;
		vector<CDigital>::iterator pd;
		pd = lower_bound(m_vDigital.begin(),m_vDigital.end(),CDigital(dwYXNo));
		if ((pd !=m_vDigital.end()) && (pd->GetYXNo() == dwYXNo))
			pDigital = pd->GetThis();
		return pDigital;
		
	}
	void Load();
	DWORD GetSize() {return m_vDigital.size();}
	void GetAll(YXData* pbyData,int& nSize)
	{
		vector<CDigital>::iterator pd = m_vDigital.begin();
		YXData* pTemp = (YXData *)pbyData;
		nSize = 0;
		for (;pd !=m_vDigital.end();pd++)
		{
			if (pd->IsValid())
			{
				pTemp->m_wDevNo = pd->GetYXNo() / 1000;
				pTemp->m_wDevPtNo = pd->GetYXNo() % 1000;
				pTemp->m_bValue = pd->GetValue()?0xff00:0xff;
				nSize += sizeof(YXData);
				pTemp++;
			}
		}
	}
	void GetAllChanged(YXData* pbyData,int& nSize)
	{
		vector<CDigital>::iterator pd = m_vDigital.begin();
		YXData* pTemp = (YXData *)pbyData;
		nSize = 0;
		for (;pd !=m_vDigital.end();pd++)
		{
			if (!pd->GetNT())
			{
				pTemp->m_wDevNo = pd->GetYXNo() / 1000;
				pTemp->m_wDevPtNo = pd->GetYXNo() % 1000;
				pTemp->m_bValue = pd->GetValue()?0xff00:0xff;
			printf("[%d][%d][%s]\n",pTemp->m_wDevNo,pTemp->m_wDevPtNo,pd->GetValue()?"TRUE":"FALSE");
				nSize += sizeof(YXData);
				pTemp++;
			}
		}
	}
protected:
	vector<CDigital> m_vDigital;
};

class CData
{
public:
	void Init();
protected:
	bool m_bWantChangedData;
};

class CIEC101Data : public CData
{

};

class CSlave
{
public:
	CSlave();
	~CSlave();
	
	void SetData();
	
};

class CAllMgr {
public: 
	CAllMgr();
	~CAllMgr();
	void AddMaster(CMAppService* pAS);
	void AddSlave(CSAppService* pAS);
	void SendDataToD(CData);//bySDevNo,DataType,pData,wSize
	void SendCmdToS();//bySDevNo,CID,pCID,wSize
	//from local slave
	void ProtInfo(BYTE* pBuf, WORD wSize);
	void YC(YCData* pYCValue,WORD wCount);
	void YX(YXData* pBoolValue,WORD wCount);
	void DD(DDData* pDDValue,WORD wCount);
	void SOE(SOEData* pSOEValue,WORD wCount);
	void SEP(SEPData* pSEPValue,WORD wCount); //保护、重合闸单个事件
	void SPE(SPEData* pSPEValue,WORD wCount); //保护启动
	void OCI(OCIData* pOCIValue,WORD wCount); //输出
	void Event(WORD wDevNo,char* pszEvent);
	//from Remote master
	bool YK(WORD wDevNo,WORD wAddr,bool bOn);
	bool GetFV(WORD wDevNo,BYTE*& pbyData,WORD& wLength,WORD wFuncCode=0);
	bool PutFV(WORD wDevNo,BYTE* pFixVal,WORD bySize,WORD wFuncCode=0);
	void YT(WORD wDevNo,WORD wAddr,bool bUp);
	void Get(WORD wDevNo,WORD wAddr,short shValue);
	void Set(WORD wDevNo,WORD wAddr,short shValue);
	void BitStr(WORD wDevNo,WORD wAddr,BYTE* pbyBitValue,WORD wCount);
	//system
	void RectifyTime(CTimeVal* ptv);
	CAnalog* GetAnalog(DWORD dwYCNo)
	{
		return m_analogs.GetAnalog(dwYCNo);
	}
	CDigital* GetDigital(DWORD dwYXNo)
	{
		return m_digitals.GetDigital(dwYXNo);
	}
	void GetAllYX(YXData* pbyData,int& nSize)
	{
//		pthread_mutex_lock(&m_mutexYX1);
		m_digitals.GetAll(pbyData,nSize);
//		pthread_mutex_unlock(&m_mutexYX1);
	}
	void GetAllYC(YCData* pbyData,int& nSize)
	{
//		pthread_mutex_lock(&m_mutexYC1);
		m_analogs.GetAll(pbyData,nSize);
//		pthread_mutex_unlock(&m_mutexYC1);
	}
	void GetAllYXChanged(YXData* pbyData,int& nSize)
	{
//		pthread_mutex_lock(&m_mutexYX1);
		m_digitals.GetAllChanged(pbyData,nSize);
//		pthread_mutex_unlock(&m_mutexYX1);
	}
	void GetAllYCChanged(YCData* pbyData,int& nSize)
	{
//		pthread_mutex_lock(&m_mutexYC1);
		m_analogs.GetAllChanged(pbyData,nSize);
//		pthread_mutex_unlock(&m_mutexYC1);
	}
	bool CAllMgr::Init();
	void CAllMgr::Run();
protected:
	CAnalogs	m_analogs;
	CDigitals	m_digitals;
//	CMonitorSvr*	m_pMonitorSvr;
#ifdef _BACK
	CModbusTCPSlave*		m_pMonitorSvr ;
	CMonitorTCPSlave*		m_pMonitor ;
//	CMySal*	m_pMonitorSvr;
#endif
	bool AllThreadOK();
	CChannelMgr*	m_pChannelMgr;
	vector<CSAppService* >	m_listSlave;
	vector<CMAppService* >	m_listMaster;
	CMAppService* GetMAppService(WORD wDevNo)
	{
		CMAppService* pAppService = NULL;
		vector<CMAppService* >::iterator o= m_listMaster.begin();
		for (BYTE bbb=0; bbb<m_listMaster.size();bbb++)
		{
			CMAppService* pTemp = *o;
			if (pTemp->IsMyDev(wDevNo))
			{
				pAppService = pTemp;
				break;
			}
			o++;
		}
		return pAppService;
	}
private:
#ifdef _DEMO
	CTimeVal m_tmInit;
#endif
	bool LicenseIsOk(void);
	bool m_bLicenseIsOk;
	CWDog	m_wdog;
	//RectifyTime from Remote or GPS;
	bool	m_bSyncClockFrmRemote;
	bool	m_bUPSAbnormal;
	bool	m_bCtrlFromRemote; //远方控制
	bool	m_bOnDuty;//有人值守
	pthread_t m_hThread;
	pthread_mutex_t	m_mutexYC;
	pthread_mutex_t	m_mutexYX;
	queue<YCData>	m_quYCData;
	queue<YXData>	m_quYXData;
friend void* Monitor(void *pVoid);
friend class CMonitorTCPSlave;
};


#endif