dnp3.h

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

	}
	WORD	m_wIndex;
	WORD	m_wDevNo;
	WORD	m_wDevPubAddr;
	short	m_shValue;
	float	m_fCoef;
	float	m_fDeadband;
	bool	m_bValid;
	bool	m_bChanged;
	struFlag	m_flag;
	WORD GetIndex() {return m_wIndex;}
	BYTE GetFlag() {BYTE* pby = (BYTE *)&m_flag;return *pby;}
	void SetValue(float fValue)
	{
		short shValue = (short) (fValue/m_fCoef);
		if ((abs(m_shValue - shValue)>m_fDeadband) || (m_flag.bitRestart == 1) || (m_flag.bitOnLine == 0))
			m_bChanged = true;
		m_flag.bitRestart = 0;
		m_flag.bitOnLine = 1;
		m_shValue = shValue;
	}
	short	GetValue()
	{
		m_bChanged = false;
		return m_shValue;
	}
};

typedef vector<CDNP3YCInfo> CDNP3YCVector;
typedef map<CDevFactor,CDNP3YCVector::iterator,less<CDevFactor> > CDNP3YCMap;

class CDNP3YCInfos
{
public:
	void Load();
	void Sort()
	{
		sort(m_setYCInfo.begin(),m_setYCInfo.end());
		CDNP3YCVector::iterator p = m_setYCInfo.begin();
		for ( ;p != m_setYCInfo.end(); p++)
		{
			CDevFactor df(p->m_wDevNo,p->m_wDevPubAddr);
//		cout << "DNP3YCNo: "<< p->m_wDevNo << "|" << p->m_wDevPubAddr << endl;
			m_mapYCInfo.insert(CDNP3YCMap::value_type(df,p));
		}
	}
	void SetValue(WORD wDevNo,WORD wDevPubAddr,float fValue)
	{
		CDNP3YCVector::iterator pDNP3YCInfo = m_setYCInfo.end();
		CDNP3YCMap::iterator p =  m_mapYCInfo.find(CDevFactor(wDevNo,wDevPubAddr));
		if (p != m_mapYCInfo.end())
		{
			pair<CDevFactor,CDNP3YCVector::iterator> temp = *p;
			pDNP3YCInfo = temp.second;
		}
		if (pDNP3YCInfo != m_setYCInfo.end())
			pDNP3YCInfo->SetValue(fValue);
	}
	bool GetValue(WORD wIndex,BYTE* pData,WORD& wSize,BYTE byType) //byType:=Variation
	{
		bool bRet = false;
		CDNP3YCInfo x(wIndex);
		CDNP3YCVector::iterator it = lower_bound(m_setYCInfo.begin(),m_setYCInfo.end(),x);
		if ((it!=m_setYCInfo.end()) &&  (it->m_wIndex == wIndex))
		{
			WORD* pw = (WORD *)&pData[wSize];
			if (byType == 2)
			{
				BYTE* pbyFlag = (BYTE *)pw;
				*pbyFlag++ = it->GetFlag();
				wSize += 1;
				pw = (WORD *)pbyFlag;
			}
			*pw = it->GetValue();
			wSize += 2;
			bRet = true;
		}
		return bRet;
	}
	bool GetAllValues(BYTE* pData,WORD& wSize,BYTE byType) //byType:=Variation
	{
		bool bRet = false;
		CDNP3YCVector::iterator it = m_setYCInfo.begin();
		WORD www = 0;
		for (;it!=m_setYCInfo.end();it++)
		{
			WORD* pw = (WORD *)&pData[www];
			if (byType == 2)
			{
				BYTE* pbyFlag = (BYTE *)pw;
				*pbyFlag++ = it->GetFlag();
				wSize += 1;
				www += 1;
				pw = (WORD *)pbyFlag;
			}
			*pw = it->GetValue();
			wSize += 2;
			www += 2;
			bRet = true;
		}
		return bRet;
	}
	WORD GetChangedValues(BYTE* pData,WORD& wSize,BYTE byType) //byType:=Variation
	{
		WORD wRet = 0;
		CDNP3YCVector::iterator it = m_setYCInfo.begin();
		WORD www = 0;
		for (;it!=m_setYCInfo.end();it++)
		{
			if (it->m_bChanged)
			{
				WORD* pw = (WORD *)&pData[www];
				*pw++ = it->GetIndex();
				wSize += 2; www += 2;
				if (byType == 2)
				{
					BYTE* pbyFlag = (BYTE *)pw;
					*pbyFlag++ = it->GetFlag();
					wSize += 1; www += 1;
					pw = (WORD *)pbyFlag;
				}
				*pw = it->GetValue();
				wSize += 2; www += 2;
				wRet++;
			}
		}
		return wRet;
	}
	bool HasChanged()
	{
		bool bRet = false;
		CDNP3YCVector::iterator it = m_setYCInfo.begin();
		for (;it!=m_setYCInfo.end();it++)
		{
			if (it->m_bChanged)
			{
				bRet = true;
				break;
			}
		}
		return bRet;
	}
	void Add(CDNP3YCSet& setYC)
	{
		CDNP3YCInfo d(setYC);
		m_setYCInfo.push_back(d);
	}
	WORD GetSize()
	{
	 	return m_setYCInfo.size();
	}
protected:
	CDNP3YCVector m_setYCInfo;
	CDNP3YCMap m_mapYCInfo;
};

class CDNP3SOEInfo
{
public:
	CDNP3SOEInfo(WORD wIndex)
	{
		m_wIndex = wIndex & 0xfff;
	}
/*	CDNP3SOEInfo(struDNP3Info* pstruDNP3)
	{
		m_wIndex = pstruDNP3->m_wPubAddr&0xfff;
		m_wDevNo = pstruDNP3->m_wDevNo;
		m_wDevPubAddr = pstruDNP3->m_wDevPubAddr;
	}
*/	CDNP3SOEInfo(CDNP3YXSet& setYX)
	{
		m_wIndex = setYX.m_wLocalNo&0xfff;
		m_wDevNo = setYX.m_dwYXNo/10000;
		m_wDevPubAddr = setYX.m_dwYXNo%10000;
	}
	bool operator <(CDNP3SOEInfo info) const
	{
		bool bRet = false;
		if (m_wIndex < info.m_wIndex)
			bRet = true;
		return bRet;
	}
	bool operator ==(CDNP3SOEInfo info) const
	{
		bool bRet = false;
		if (m_wIndex == info.m_wIndex)
			bRet = true;
		return bRet;
	}
	WORD	m_wIndex;//<=0xfff
	WORD	m_wDevNo;
	WORD	m_wDevPubAddr;
};

typedef vector<CDNP3SOEInfo> CDNP3SOEVector;
typedef map<CDevFactor,CDNP3SOEVector::iterator,less<CDevFactor> > CDNP3SOEMap;

class CDNP3SOEData
{
public:
	void operator=(CDNP3SOEData d)
	{
		memcpy(m_abySOEData,d.m_abySOEData,9);
	}	
	BYTE m_abySOEData[9];
};

class CDNP3SOEInfos
{
public:
	void Load();
	void Sort()
	{
		sort(m_setSOEInfo.begin(),m_setSOEInfo.end());
		CDNP3SOEVector::iterator p = m_setSOEInfo.begin();
		for ( ;p != m_setSOEInfo.end(); p++)
		{
			CDevFactor df(p->m_wDevNo,p->m_wDevPubAddr);
			m_mapSOEInfo.insert(CDNP3SOEMap::value_type(df,p));
		}
	}
	void SetValue(SOEData* pSOEValue)
	{
		WORD wDevNo = pSOEValue->m_wDevNo;
		WORD wDevPubAddr = pSOEValue->m_wDevPtNo;
		
		CDNP3SOEVector::iterator pDNP3SOEInfo = m_setSOEInfo.end();
		CDNP3SOEMap::iterator p =  m_mapSOEInfo.find(CDevFactor(wDevNo,wDevPubAddr));
		if (p != m_mapSOEInfo.end())
		{
			pair<CDevFactor,CDNP3SOEVector::iterator> temp = *p;
			pDNP3SOEInfo = temp.second;
		}
		if (pDNP3SOEInfo != m_setSOEInfo.end())
			AddSOEData(&pSOEValue->m_ctv,pDNP3SOEInfo->m_wIndex,pSOEValue->m_bValue);
	}
	BYTE GetSOEData(BYTE* pData,WORD& wSize,BYTE byCount=18)
	{
		BYTE byRet = 0;
		vector<CDNP3SOEData>::iterator pSOEData = m_queSOE.begin();
		while ((pSOEData != m_queSOE.end())&& (byRet <= byCount))
		{
			memcpy(pData,pSOEData->m_abySOEData,9);
			pSOEData = m_queSOE.erase(pSOEData);
			pData += 9;
			wSize += 9;
			byRet++;
			
		}
		return byRet;
	}
	bool HasData()
	{
	 	return m_queSOE.size();
	}
	void Add(CDNP3YXSet& setYX)
	{
		CDNP3SOEInfo d(setYX);
		m_setSOEInfo.push_back(d);
	}
protected:
	CDNP3SOEVector m_setSOEInfo;
	CDNP3SOEMap m_mapSOEInfo;
	void AddSOEData(CTimeVal* ptv,WORD wIndex,BOOL IsOn);
private:
	vector<CDNP3SOEData>		m_queSOE;
};
/*
class CDNP3DDInfo
{
public:
	CDNP3DDInfo(WORD wIndex)
	{
		m_wIndex = wIndex;
		m_bChanged = false;
	}
	CDNP3DDInfo(CDNP3DDSet& setDD)
	{
		m_wIndex = setDD.m_wLocalNo;
		m_wDevNo = setDD.m_dwYCNo/10000;
		m_wDevPubAddr = setDD.m_dwYCNo%10000;
		m_fDeadband = setDD.m_fDeadBand;
		m_dwValue = 0x80000000;
		m_bChanged = false;
	}
	bool operator <(CDNP3DDInfo info) const
	{
		bool bRet = false;
		if (m_wIndex < info.m_wIndex)
			bRet = true;
		return bRet;
	}
	bool operator ==(CDNP3DDInfo info) const
	{
		bool bRet = false;
		if (m_wIndex == info.m_wIndex)
			bRet = true;
		return bRet;
	}
	bool operator !=(CDNP3DDInfo info) const
	{
		bool bRet = false;
		if (m_wIndex != info.m_wIndex)
			bRet = true;
		return bRet;
	}
	WORD	m_wIndex;
	BYTE	m_byType; //
	WORD	m_wDevNo;
	WORD	m_wDevPubAddr;
	float	m_fDeadband;
	bool	m_bChanged;
	DWORD GetValue() const
	{
		DWORD dwValue = m_dwValue;
		if (m_bFrz)
			dwValue = m_dwFrzValue;
		return dwValue;
	}
	void SetValue(DWORD dwValue)
	{
		if (abs(m_dwValue - dwValue)>m_fDeadband)
			m_bChanged = true;
		m_dwValue = dwValue;
	}
	void Frz()
	{
		m_bFrz = true;
		m_dwFrzValue = m_dwValue;
		m_tmvFrz = CTimeVal::GetCurrentTime();
	}
protected:
	DWORD	m_dwValue;
	BYTE	m_byFlag;
	DWORD	m_dwFrzValue;
	bool	m_bFrz;
	CTimeVal	m_tmvFrz;
};

typedef vector<CDNP3DDInfo> CDNP3DDVector;
typedef map<CDevFactor,CDNP3DDVector::iterator,less<CDevFactor> > CDNP3DDMap;

class CDNP3DDInfos
{
public:
	void Load();

	void Sort()
	{
		sort(m_setDDInfo.begin(),m_setDDInfo.end());
	}
	void SetValue(WORD wDevNo,WORD wDevPubAddr,DWORD dwValue)
	{
		CDNP3DDMap::iterator p =  m_mapDDInfo.lower_bound(CDevFactor(wDevNo,wDevPubAddr));
		if (p != m_mapDDInfo.end())
		{
			pair<CDevFactor,CDNP3DDVector::iterator> temp = *p;
			CDNP3DDVector::iterator pDNP3DDInfo = temp.second;
			if (pDNP3DDInfo != m_setDDInfo.end())
				pDNP3DDInfo->SetValue(dwValue);
		}
	}
	bool GetData(WORD wIndex,BYTE* pData,WORD& wSize,BYTE byVariation) //byVariation:=1;:=3;:=
	{
		bool bRet = false;
		CDNP3DDVector::iterator pDNP3DDInfo = m_setDDInfo.lower_bound(CDNP3DDInfo(wIndex));
		if ((pDNP3DDInfo!=m_setDDInfo.end()) && (pDNP3DDInfo->m_wIndex == wIndex))
		{
			WORD* pw = (WORD *)&pData[wSize];
			*pw = wIndex;
			wSize += 2;
			DWORD* pdw = (DWORD *)&pData[wSize];
			*pdw = pDNP3DDInfo->GetValue();
			wSize += 4;
			bRet = true;
		}
		return bRet;
	}
	bool GetDatas(BYTE* pData,WORD& wSize)
	{
		wSize = 0;
		CDNP3DDVector::iterator pDNP3DDInfo = m_setDDInfo.begin();
		for (;pDNP3DDInfo!=m_setDDInfo.end();pDNP3DDInfo++)
		{
			DWORD* pdw = (DWORD *)&pData[wSize];
			*pdw = pDNP3DDInfo->GetValue();
			wSize += 4;
		}
		return (wSize > 0);
	}
	void Add(CDNP3DDSet& setDD)
	{
		CDNP3DDInfo d(setDD);
		m_setDDInfo.push_back(d);
	}
protected:
	CDNP3DDVector m_setDDInfo;
	CDNP3DDMap m_mapDDInfo;
};
*/
#endif