cdt.h

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

	BYTE	m_byType; //&0xf = 1,2,3
	WORD	m_wDevNo;
	WORD	m_wDevPubAddr;
	WORD	m_wValue;
	float	m_fCoef;
	bool	m_bValid;
	void SetValue(float fValue)
	{
		short shValue = (short) (fValue/m_fCoef);
		m_bValid = true;
		switch (m_byType & 0xf0)
		{
		case 0:
		case 1:
		case 2:
		case 3:
		{
			bool bMinus = false;
			if (shValue < 0)
			{
				shValue = -shValue;
				bMinus = true;
			}
			WORD* pw = (WORD *)&shValue;
			m_wValue = *pw & 0x7ff;
			if (*pw > 0x7ff)
				m_wValue |= 0x4000;
			if (bMinus)
			{
				m_wValue = ~m_wValue +1;
				m_wValue &= 0x7ff;
				m_wValue |= 0x800;
			}
			break;
		}
		case 0x10://ZJ
		{
			m_wValue = (WORD) shValue;
			break;
		}
		case 0x20://F
		{
			break;
		}
		case 0x30://Water
		{
			break;
		}
		default: break;
		}
	}
	short	GetValue(bool& bInvalid,bool& bOverflow)
	{
		bInvalid = m_bValid;
		bOverflow = false;
		short shValue = 0;
		switch (m_byType & 0xf0)
		{
		case 0:
		case 1:
		case 2:
		case 3:
		{
//			if (m_wValue & 0x8000)
//				bInvalid = true;
			if (m_wValue & 0x4000)
				bOverflow = true;
			else
			{
				if (m_wValue & 0x800)
					shValue = -((~m_wValue +1) & 0x7ff);
				else shValue = m_wValue & 0x7ff;
			}
			break;
		}
		case 0x10://ZJ
		{
			m_wValue = (WORD) shValue;
			break;
		}
		case 0x20://F
		{
			break;
		}
		case 0x30://Water
		{
			break;
		}
		default: break;
		}
		return shValue;
	}
};

typedef vector<CCDTYCInfo> CCDTYCVector;
typedef map<CDevFactor,CCDTYCVector::iterator,less<CDevFactor> > CCDTYCMap;

class CCDTYCInfos
{
public:
	void Load();
	void Sort()
	{
		sort(m_setYCInfo.begin(),m_setYCInfo.end());
		CCDTYCVector::iterator p = m_setYCInfo.begin();
		for ( ;p != m_setYCInfo.end(); p++)
		{
			CDevFactor df(p->m_wDevNo,p->m_wDevPubAddr);
			m_mapYCInfo.insert(CCDTYCMap::value_type(df,p));
		}
	}
	void SetValue(WORD wDevNo,WORD wDevPubAddr,float fValue)
	{
		CCDTYCVector::iterator pCDTYCInfo = m_setYCInfo.end();
		CCDTYCMap::iterator p =  m_mapYCInfo.find(CDevFactor(wDevNo,wDevPubAddr));
		if (p != m_mapYCInfo.end())
		{
			pair<CDevFactor,CCDTYCVector::iterator> temp = *p;
			pCDTYCInfo = temp.second;
		}
		if (pCDTYCInfo != m_setYCInfo.end())
			pCDTYCInfo->SetValue(fValue);
	}
	bool GetYCData(BYTE byType,BYTE* pData,WORD& wSize)
	{
		wSize = 0;
		CCDTYCInfo x(byType,0,0);
		CCDTYCVector::iterator pCDTYCInfo1 = lower_bound(m_setYCInfo.begin(),m_setYCInfo.end(),x);
		while ((pCDTYCInfo1!=m_setYCInfo.end()) &&  (pCDTYCInfo1->m_byType == byType))
		{
			if (pCDTYCInfo1->m_byPubAddr >0x7f) break;
			if (pCDTYCInfo1->m_bValid == false)
			{
				pCDTYCInfo1 += 2;
				continue;
			}
			pData[wSize] = pCDTYCInfo1->m_byPubAddr;			
			WORD* pw = (WORD *)&pData[wSize + 1];
			pw[0] = pCDTYCInfo1->m_wValue;
			pCDTYCInfo1++;
			CCDTYCVector::iterator pCDTYCInfo2 = pCDTYCInfo1;
			if ((pCDTYCInfo2!=m_setYCInfo.end())&& (pCDTYCInfo2->m_byType == byType))
			{
				if (pCDTYCInfo2->m_byPubAddr == pCDTYCInfo1->m_byPubAddr)
				{
					if (pCDTYCInfo2->m_bValid == false)
					{
						pCDTYCInfo1++;
						continue;
					}
					pw[1] = pCDTYCInfo2->m_wValue;
					pCDTYCInfo2++;
					pCDTYCInfo1 = pCDTYCInfo2;
				}
				else	pw[1] = 0x8000;
			}
			else	pw[1] = 0x8000;
			if ((pw[0] != 0x8000) || (pw[1] !=0x8000))
				wSize += 6;
		}
		return (wSize > 0);
	}
/*	void Add(struCDTInfo* pstruCDTYC)
	{
		CCDTYCInfo d(pstruCDTYC);
		m_setYCInfo.push_back(d);
	}
*/	void Add(CCDTYCSet& setYC)
	{
		CCDTYCInfo d(setYC);
		m_setYCInfo.push_back(d);
	}
protected:
	CCDTYCVector m_setYCInfo;
	CCDTYCMap m_mapYCInfo;
};

class CCDTSOEInfo
{
public:
	CCDTSOEInfo(WORD wIndex)
	{
		m_wIndex = wIndex & 0xfff;
	}
/*	CCDTSOEInfo(struCDTInfo* pstruCDT)
	{
		m_wIndex = pstruCDT->m_wPubAddr&0xfff;
		m_wDevNo = pstruCDT->m_wDevNo;
		m_wDevPubAddr = pstruCDT->m_wDevPubAddr;
	}
*/	CCDTSOEInfo(CCDTYXSet& setYX)
	{
		m_wIndex = setYX.m_wLocalNo&0xfff;
		m_wDevNo = setYX.m_dwYXNo/1000;
		m_wDevPubAddr = setYX.m_dwYXNo%1000;
	}
	bool operator <(CCDTSOEInfo info) const
	{
		bool bRet = false;
		if (m_wIndex < info.m_wIndex)
			bRet = true;
		return bRet;
	}
	bool operator ==(CCDTSOEInfo 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<CCDTSOEInfo> CCDTSOEVector;
typedef map<CDevFactor,CCDTSOEVector::iterator,less<CDevFactor> > CCDTSOEMap;

class CCDTSOEData
{
public:
	CCDTSOEData() {m_byTimes = 0;}
	void operator=(CCDTSOEData d)
	{
		memcpy(m_abySOEData,d.m_abySOEData,12);
	}	
	BYTE m_abySOEData[12];
	BYTE m_byTimes;
};

class CCDTSOEInfos
{
public:
	void Load();
	void Sort()
	{
		sort(m_setSOEInfo.begin(),m_setSOEInfo.end());
		CCDTSOEVector::iterator p = m_setSOEInfo.begin();
		for ( ;p != m_setSOEInfo.end(); p++)
		{
			CDevFactor df(p->m_wDevNo,p->m_wDevPubAddr);
			m_mapSOEInfo.insert(CCDTSOEMap::value_type(df,p));
		}
	}
	void SetValue(WORD wDevNo,WORD wDevPubAddr,SOEData* pSOEValue)
	{
		CCDTSOEVector::iterator pCDTSOEInfo = m_setSOEInfo.end();
		CCDTSOEMap::iterator p =  m_mapSOEInfo.find(CDevFactor(wDevNo,wDevPubAddr));
		if (p != m_mapSOEInfo.end())
		{
			pair<CDevFactor,CCDTSOEVector::iterator> temp = *p;
			pCDTSOEInfo = temp.second;
		}
		if (pCDTSOEInfo != m_setSOEInfo.end())
			AddSOEData(&(pSOEValue->m_ctv),pCDTSOEInfo->m_wIndex,pSOEValue->m_bValue);
	}
	bool GetSOEData(BYTE* pData,WORD& wSize)
	{
		wSize = 0;
		vector<CCDTSOEData>::iterator pSOEData = m_queSOE.begin();
		while ((pSOEData != m_queSOE.end())&& (wSize <= 120))
		{
			memcpy(pData,pSOEData->m_abySOEData,12);
			pSOEData->m_byTimes++;
			if (pSOEData->m_byTimes >= 3)
				pSOEData = m_queSOE.erase(pSOEData);
			else pSOEData++;
			pData += 12;
			wSize += 12;
			
		}
		return (wSize > 0);
	}
/*	void Add(struCDTInfo* pstruCDT)
	{
		CCDTSOEInfo d(pstruCDT);
		m_setSOEInfo.push_back(d);
	}
*/	void Add(CCDTYXSet& setYX)
	{
		CCDTSOEInfo d(setYX);
		m_setSOEInfo.push_back(d);
	}
protected:
	CCDTSOEVector m_setSOEInfo;
	CCDTSOEMap m_mapSOEInfo;
	void AddSOEData(CTimeVal* ptv,WORD wIndex,BOOL IsOn);
private:
	vector<CCDTSOEData>		m_queSOE;
};

class CCDTDDInfo
{
public:
	CCDTDDInfo(BYTE byPubAddr, BYTE byIndex)
	{
		m_byPubAddr = byPubAddr;
	}
/*	CCDTDDInfo(struCDTInfo* pstruCDT)
	{
		m_byPubAddr = (pstruCDT->m_wPubAddr&0xff00)>>8;
		m_byType = pstruCDT->m_byType;
		m_wDevNo = pstruCDT->m_wDevNo;
		m_wDevPubAddr = pstruCDT->m_wDevPubAddr;
		m_dwValue = 0x80000000;
	}
*/	CCDTDDInfo(CCDTDDSet& setDD)
	{
		m_byPubAddr = setDD.m_wLocalNo+0xa0;//m_dwYCNo;//(pstruCDT->m_wPubAddr&0xff00)>>8;
		m_wDevNo = setDD.m_dwYCNo/1000;
		m_wDevPubAddr = setDD.m_dwYCNo%1000;
		m_dwValue = 0x80000000;
	}
	bool operator <(CCDTDDInfo info) const
	{
		bool bRet = false;
		if (m_byPubAddr < info.m_byPubAddr)
			bRet = true;
		return bRet;
	}
	bool operator ==(CCDTDDInfo info) const
	{
		bool bRet = false;
		if (m_byPubAddr == info.m_byPubAddr)
			bRet = true;
		return bRet;
	}
	bool operator !=(CCDTDDInfo info) const
	{
		bool bRet = false;
		if (m_byPubAddr != info.m_byPubAddr)
			bRet = true;
		return bRet;
	}
	BYTE	m_byPubAddr; //>=0xa0 and <0xdf;
	BYTE	m_byType; //
	WORD	m_wDevNo;
	WORD	m_wDevPubAddr;
	
	DWORD GetValue() const
	{
		DWORD dwValue = m_dwValue;
		if (m_bFrz)
			dwValue = m_dwFrzValue;
		return dwValue;
	}
	void SetValue(DWORD dwValue)
	{
		m_dwValue = dwValue & 0xfffffff;
		if (dwValue > 0xfffffff)
			m_dwValue |= 0x80000000;
	}
	void Frz()
	{
		m_bFrz = true;
		m_dwFrzValue = m_dwValue;
	}
protected:
	DWORD	m_dwValue;
	DWORD	m_dwFrzValue;
	bool m_bFrz;
};

typedef vector<CCDTDDInfo> CCDTDDVector;
typedef map<CDevFactor,CCDTDDVector::iterator,less<CDevFactor> > CCDTDDMap;

class CCDTDDInfos
{
public:
	void Load();
	void Sort()
	{
		sort(m_setDDInfo.begin(),m_setDDInfo.end());
	}
	void SetValue(WORD wDevNo,WORD wDevPubAddr,DWORD dwValue)
	{
		CCDTDDMap::iterator p =  m_mapDDInfo.lower_bound(CDevFactor(wDevNo,wDevPubAddr));
		if (p != m_mapDDInfo.end())
		{
			pair<CDevFactor,CCDTDDVector::iterator> temp = *p;
			CCDTDDVector::iterator pCDTDDInfo = temp.second;
			if (pCDTDDInfo != m_setDDInfo.end())
				pCDTDDInfo->SetValue(dwValue);
		}
	}
	bool GetDDData(/*BYTE byType,*/BYTE* pData,WORD& wSize)
	{
		wSize = 0;
		CCDTDDVector::iterator pCDTDDInfo = m_setDDInfo.begin();
		for (;pCDTDDInfo!=m_setDDInfo.end();pCDTDDInfo++)
		{
			if (pCDTDDInfo->m_byPubAddr <0xa0) continue;
			if (pCDTDDInfo->m_byPubAddr >0xdf) break;
			
			pData[wSize] = pCDTDDInfo->m_byPubAddr;			
			DWORD* pdw = (DWORD *)&pData[wSize + 1];
			*pdw = pCDTDDInfo->GetValue();
			wSize += 6;
		}
		return (wSize > 0);
	}
/*	void Add(struCDTInfo* pstruCDT)
	{
		CCDTDDInfo d(pstruCDT);
		m_setDDInfo.push_back(d);
	}
*/	void Add(CCDTDDSet& setDD)
	{
		CCDTDDInfo d(setDD);
		m_setDDInfo.push_back(d);
	}
protected:
	CCDTDDVector m_setDDInfo;
	CCDTDDMap m_mapDDInfo;
};

#endif