iec8705101.h

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

			m_bitBCD1 = pBuf[0] & 0xf;
			m_bitBCD2 = (pBuf[0] & 0xf0) >> 4;
			m_bitBCD3 = pBuf[1] & 0xf;
			m_bitBCD4 = (pBuf[1] & 0xf0)>>4;
			m_bitBCD5 = pBuf[2] & 0xf;
			m_bitBCD6 = (pBuf[2] & 0xf0)>>4;
		}
		return bRet;	
	}
	BYTE ToBuf(BYTE * pBuf)
	{
		pBuf[0] = m_bitBCD1 | (m_bitBCD2<<4);
		pBuf[1] = m_bitBCD3 | (m_bitBCD4<<4);
		pBuf[2] = m_bitBCD5 | (m_bitBCD6<<4);
		return GetLen();
	}
	static BYTE GetLen(){return (BYTE)3 + CQDS::GetLen();}
	static DataType	GetDT() {return DT_eBCD;}
protected:
	BYTE m_bitBCD1:4;//0.01
	BYTE m_bitBCD2:4;//0.1
	BYTE m_bitBCD3:4;//1
	BYTE m_bitBCD4:4;//10
	BYTE m_bitBCD5:4;//100
	BYTE m_bitBCD6:4;//1000
};

class CDCO
{
public:
	bool FromBuf(BYTE* pBuf,BYTE bySize)
	{
		bool bRet = false;
		if (bySize >= GetLen())
		{
			m_bitS_E = (pBuf[0] & 0x80)>>7;
			m_bitQU = (pBuf[0] & 0x3c) >> 2;
			m_bitRCS = pBuf[1] & 0x3;
		}
		return bRet;	
	}
	BYTE ToBuf(BYTE * pBuf)
	{
		pBuf[0] = (m_bitS_E<<7) | (m_bitQU<<2) | m_bitRCS;
		return GetLen();
	}
	static BYTE GetLen(){return (BYTE)1;}
	static DataType	GetDT() {return DT_eDCO;}
	bool IsOn(bool& bOn)
	{
		bool bRet = false;
		if ((m_bitRCS  == 1) || (m_bitRCS  == 2))
		{
			bRet = true;
			bOn = (m_bitRCS == 1)?false:true;
		}
		return bRet;
	}
	bool S_E() {return (m_bitS_E != 0) ? true : false;}
protected:
	BYTE m_bitS_E:1;//<0>:执行；<1>:选择
	BYTE m_bitQU:5;//持续时间
	BYTE m_bitRCS:2;//<1>:OFF,降一步;<2>:ON,升一步
};

class CRCO
{
public:
	bool FromBuf(BYTE* pBuf,BYTE bySize)
	{
		bool bRet = false;
		if (bySize >= GetLen())
		{
			m_bitS_E = (pBuf[0] & 0x80)>>7;
			m_bitQU = (pBuf[0] & 0x3c) >> 2;
			m_bitRCS = pBuf[1] & 0x3;
		}
		return bRet;	
	}
	BYTE ToBuf(BYTE * pBuf)
	{
		pBuf[0] = (m_bitS_E<<7) | (m_bitQU<<2) | m_bitRCS;
		return GetLen();
	}
	static BYTE GetLen(){return (BYTE)1;}
	static DataType	GetDT() {return DT_eRCO;}
	bool IsOn(bool& bOn)
	{
		bool bRet = false;
		if ((m_bitRCS  == 1) || (m_bitRCS  == 2))
		{
			bRet = true;
			bOn = (m_bitRCS == 1)?false:true;
		}
		return bRet;
	}
	bool S_E() {return (m_bitS_E == 1) ? true : false;}
protected:
	BYTE m_bitS_E:1;//<0>:执行；<1>:选择
	BYTE m_bitQU:5;//
	BYTE m_bitRCS:2;//<1>:OFF,降一步;<2>:ON,升一步
};

class CNULL
{
public:
	bool FromBuf(BYTE* pBuf,BYTE bySize) {return true;}
	BYTE ToBuf(BYTE * pBuf){return GetLen();}
	static BYTE GetLen(){return (BYTE)0;}
	static DataType	GetDT() {return DT_eREAD;}
};

class CTest
{
public:
	bool FromBuf(BYTE* pBuf,BYTE bySize)
	{
		bool bRet = false;
		if (bySize == 2)
		{
			WORD* pw = (WORD *)pBuf;
			m_wValue = *pw;
			if (m_wValue == 0x55aa)
				bRet = true;
		}
		return bRet;
	}
	BYTE ToBuf(BYTE * pBuf)
	{
		*pBuf++ = 0xaa;
		*pBuf = 0x55;
		return GetLen();
	}
	static BYTE GetLen(){return (BYTE)2;}
	static DataType	GetDT() {return DT_eTEST;}
protected:
	WORD m_wValue;//=0x55aa
};

/*
class CTHV
{
public:
	bool FromBuf(BYTE* pBuf,BYTE bySize)
	BYTE& ToBuf(BYTE * pBuf)
protected:
	unsigned short m_wTHV;
};

class CFLT
{
public:
	BYTE& ToBuf(BYTE * pBuf)
	bool FromBuf(BYTE* pBuf,BYTE bySize)
protected:
	unsigned short m_wFLT;
};

class CLMT
{
public:
	BYTE& ToBuf(BYTE * pBuf)
	bool FromBuf(BYTE* pBuf,BYTE bySize)
protected:
	short m_wLMT;
};

class CQPM
{
public:
	BYTE& ToBuf(BYTE * pBuf)
	bool FromBuf(BYTE* pBuf,BYTE bySize)
protected:
	int m_bitKPA:6;
	int m_bitLPC:1;
	int m_bitPOP:1;
};

class CQPA
{
public:
	BYTE& ToBuf(BYTE * pBuf)
	bool FromBuf(BYTE* pBuf,BYTE bySize)
protected:
	BYTE m_byQPA;
};

class CQRP
{
public:
	BYTE& ToBuf(BYTE * pBuf)
	bool FromBuf(BYTE* pBuf,BYTE bySize)
protected:
	BYTE m_byQRP;
};
*/
class CQCC
{
public:
	bool FromBuf(BYTE* pBuf,BYTE bySize)
	{
		bool bRet = false;
		if (bySize >= GetLen())
		{
			m_bitFRZ = (pBuf[0] & 0xc0)>>6;
			m_bitRQT = pBuf[0] & 0x3f;
		}
		return bRet;	
	}
	BYTE ToBuf(BYTE * pBuf)
	{
		pBuf[0] = (m_bitFRZ<<6) | m_bitRQT;
		return GetLen();
	}
	static BYTE GetLen(){return (BYTE)1;}
	static DataType	GetDT() {return DT_eQCC;}
	BYTE GetValue() {return m_bitFRZ<<6 + m_bitRQT;}
	void SetValue(BYTE byValue) 
	{
		m_bitFRZ = (byValue & 0xc0)>>6;
		m_bitRQT = byValue & 0x3f;
	}
protected:
	BYTE m_bitFRZ:2;
	BYTE m_bitRQT:6;
};

class CQOI
{
public:
	bool FromBuf(BYTE* pBuf,BYTE bySize)
	{
		bool bRet = false;
		if (bySize >= GetLen())
			m_byQOI = pBuf[0];
		return bRet;	
	}
	BYTE ToBuf(BYTE * pBuf)
	{
		pBuf[0] = m_byQOI;
		return GetLen();
	}
	static BYTE GetLen(){return (BYTE)1;}
	static DataType	GetDT() {return DT_eQOI;}
	BYTE GetValue() {return m_byQOI;}
protected:
	BYTE m_byQOI;
};

class CCOI //初始化原因
{
public:
	bool FromBuf(BYTE* pBuf,BYTE bySize)
	{
		bool bRet = false;
		if (bySize >= GetLen())
		{
			m_bitPI = (pBuf[0] & 0x80)>>7;
			m_bitCOI = pBuf[0] & 0x7f;
		}
		return bRet;	
	}
	BYTE ToBuf(BYTE * pBuf)
	{
		pBuf[0] = (m_bitPI<<7) | m_bitCOI;
		return GetLen();
	}
	static BYTE GetLen(){return (BYTE)1;}
	static DataType	GetDT() {return DT_eCOI;}
protected:
	BYTE m_bitCOI:7;
	BYTE m_bitPI:1;
};

class CSetBS
{
public:
	bool FromBuf(BYTE* pBuf,BYTE bySize)
	{
		bool bRet = false;
		if (bySize >= GetLen())
		{
			DWORD* pdw = (DWORD *)pBuf;
			m_dwValue = *pdw;
		}
		return bRet;	
	}
	BYTE ToBuf(BYTE * pBuf)
	{
		DWORD* pdw = (DWORD *)pBuf;
		*pdw = m_dwValue;
		return GetLen();
	}
	static BYTE GetLen(){return (BYTE)4;}
	static DataType	GetDT() {return DT_eSETBS;}
	DWORD GetValue() {return m_dwValue;}
	void GetValue(DWORD dwValue) {m_dwValue = dwValue;}
protected:
	DWORD m_dwValue;
};

class CBO : public CSetBS
{
public:
	bool FromBuf(BYTE* pBuf,BYTE bySize)
	{
		bool bRet = false;
		if (bySize >= GetLen())
		{
			CSetBS::FromBuf(pBuf,bySize);
			pBuf += CSetBS::GetLen();
			m_bitIV = (pBuf[0] & 0x80) >> 7;
			m_bitNT = (pBuf[0] & 0x40) >> 6;
			m_bitSB = (pBuf[0] & 0x20) >> 5;
			m_bitBL = (pBuf[0] & 0x10) >> 4;
			bRet = true;
		}
		return bRet;
	}
	BYTE ToBuf(BYTE * pBuf)
	{
		CSetBS::ToBuf(pBuf);
		pBuf += CSetBS::GetLen();
		pBuf[0] = 0;
		pBuf[0] = (m_bitIV << 7) | (m_bitNT<<6) | (m_bitSB<<5) | (m_bitBL<<4);
		return GetLen();
	}
	static BYTE GetLen(){return (BYTE)1 + CSetBS::GetLen();}
	static DataType	GetDT() {return DT_eBO;}
	DWORD GetValue() {return m_dwValue;}
	void GetValue(DWORD dwValue) {m_dwValue = dwValue;}
protected:
	BYTE	m_bitBL:1;//封锁
	BYTE	m_bitSB:1;//
	BYTE	m_bitNT:1;//<0>:当前值
	BYTE	m_bitIV:1;//<0>:有效
	BYTE	m_bitRes:4;//=0;
};


template <class TIElement>
class CIElement
{
public:
	CIElement(BYTE	byNum)
	{
		m_byNum = byNum;
	}
	~CIElement()
	{
		TIElement* pIElement;
		vector<TIElement *>::iterator r = m_listIElement.begin();
		while (r != m_listIElement.begin())
		{
			pIElement = *r++;
			delete pIElement;
		}
	}
	BYTE GetLen()
	{
		BYTE byRet = 2;
		TIElement* pIElement;
		vector<TIElement *>::iterator r = m_listIElement.begin();
		while (r != m_listIElement.end())
		{
			pIElement = *r++;
			byRet += pIElement->GetLen();
		}
		return byRet;
	}
	BYTE	GetDT()
	{
		vector<CIElement *>::reference r = m_listIElement.front();
		return r->GetDT();
	}
	BYTE ToBuf(BYTE * pBuf)
	{
		BYTE byRet = 0;
		WORD* pw = (WORD *)pBuf;
		pBuf += sizeof(WORD);
		byRet += sizeof(WORD);
		*pw = m_wAddr;
		vector<TIElement *>::iterator o = m_listIElement.begin();
		TIElement* pIElement;
		for (BYTE b=0; b<m_listIElement.size(); b++)
		{
			pIElement = *o++;
			byRet += pIElement->ToBuf(pBuf);
		}
		return byRet;
	}
	bool FromBuf(BYTE* pBuf,BYTE bySize)
	{
		bool bRet = false;
		if (bySize >= 2)
		{
			WORD* pw = (WORD *)pBuf;
			m_wAddr = *pw;
			pBuf += sizeof(WORD);
			bySize -= sizeof(WORD);
			if (bySize == 0)
			{
				if (TIElement::GetLen() == 0)
					bRet = true;
			}
			else if ((bySize%TIElement::GetLen() == 0) && (bySize/TIElement::GetLen()==m_byNum))
			{
				for (BYTE b=0; (b<m_byNum); b++)
				{
					TIElement* pIElement = new TIElement;
					if (bRet = pIElement->FromBuf(pBuf,TIElement::GetLen()))
					{
						pBuf += bySize/m_byNum;
						m_listIElement.push_back(pIElement);
					}
					else
					{
						delete pIElement;
						break;
					}
				}
			}
		}
		return bRet;
	}
	bool	GetElement(BYTE byElementNo,WORD& wAddr,TIElement*& pIElement)
	{
		bool bRet = false;
		if (byElementNo < m_byNum)
		{
			wAddr = m_wAddr + byElementNo;
//			vector<TIElement *>::iterator o = m_listIElement.begin();
			if (byElementNo < m_listIElement.size())
			{
				pIElement = m_listIElement[byElementNo];
				bRet = true;
			}
			
		}
		return bRet;
	}
	void	AddElement(WORD wAddr,TIElement* pElement)
	{
		WORD wSize = m_listIElement.size();
		if (wSize < m_byNum)
		{
			if (wSize == 0)
				m_wAddr = wAddr;
			else assert(m_wAddr == wAddr - wSize);
			m_listIElement.push_back(pElement);
		}
	}
protected:
	WORD	m_wAddr;
	BYTE	m_byTypeID;	//reserved
	vector<TIElement* > m_listIElement;
private:
	BYTE	m_byNum;
};

template <class TIElement>
class CIElements
{
public:
	CIElements(bool bIsSQ = false ,BYTE byNum = 0) //for setup
	{
	}
	CIElements(bool bIsSQ,BYTE byNum,BYTE *pData,BYTE byLen) //for explain input data
	{
	}
	~CIElements()
	{
		CIElement<TIElement> *pIElement;
		vector<CIElement<TIElement> *>::iterator o = m_listIElements.begin();
		while (o != m_listIElements.end())
		{
			pIElement = *o++;
			delete pIElement;
		}
	}
	BYTE GetLen()
	{
		BYTE byRet = 0;
		vector<CIElement<TIElement> *>::iterator r = m_listIElements.begin();
		byRet += *r->GetLen() * m_listIElements.size();
		return byRet;
	}
	BYTE	GetDT()
	{
		vector<CIElement<TIElement> *>::iterator o = m_listIElements.begin();
		return o->GetDT();
	}
	BYTE GetSQ() {return (BYTE)((m_bSQ?0x80:0) | m_bitNum);}
	void SetSQ(BYTE bySQ)
	{
		m_bSQ = (bySQ&0x80)?true:false;
		m_bitNum =  bySQ&0x7f;
	}
	BYTE ToBuf(BYTE * pBuf)
	{
		BYTE byRet = 0;
		vector<CIElement<TIElement> *>::iterator o = m_listIElements.begin();
		CIElement<TIElement> *pIElement;
		if (m_bSQ == true)
		{
			assert(m_listIElements.size() == 1);
			pIElement = *o;
			byRet = pIElement->ToBuf(pBuf);
		}
		else
		{
			assert(m_bitNum == m_listIElements.size());
			for (BYTE b=0; b<m_listIElements.size(); b++)
			{
				pIElement = *(o+b);
				byRet += pIElement->ToBuf(pBuf);
			}
		}
		return byRet;
	}
	bool FromBuf(BYTE* pBuf,BYTE bySize)
	{
		bool bRet = false;
		CIElement<TIElement> *pIElement;
		if (m_bSQ == true)
		{
			pIElement = new 	CIElement<TIElement>(m_bitNum);
			bRet = pIElement->FromBuf(pBuf,bySize);
			if (bRet == false)
				delete pIElement;
			else
				m_listIElements.push_back(pIElement);
		}
		else
		{
			for (BYTE b=0; b<m_bitNum; b++)
			{
				pIElement = new 	CIElement<TIElement>(1);
				bRet = pIElement->FromBuf(pBuf,bySize/m_bitNum);
				pBuf += bySize/m_bitNum;
				if (bRet == false)
				{
					delete pIElement;
					break;
				}
				m_listIElements.push_back(pIElement);
			}
		}
		return bRet;
	}
	bool	GetElement(BYTE byElementNo,WORD& wAddr,TIElement*& pElement)
	{
		bool bRet = false;
		if (byElementNo < m_bitNum)
		{
			vector<CIElement<TIElement> *>::iterator o = m_listIElements.begin();
			CIElement<TIElement> *pIElements;
			if (m_bSQ == 1)
			{
				assert(m_listIElements.size() == 1);
				pIElements = *o;
				bRet = pIElements->GetElement(byElementNo,wAddr,pElement);
			}
			else
			{
				assert(m_bitNum == m_listIElements.size());
				pIElements = *(o+byElementNo);
				bRet = pIElements->GetElement(0,wAddr,pElement);
			}
		}
		return bRet;
	}
	void	AddElement(WORD wAddr,TIElement* pElement)
	{
		CIElement<TIElement> *pIElements;
		if (m_bSQ == true)
		{
			if (m_listIElements.size() == 0)
			{
				pIElements = new CIElement<TIElement>(m_bitNum);
				m_listIElements.push_back(pIElements);
			}
			else
			{
				vector<CIElement<TIElement> *>::iterator o = m_listIElements.begin();
				pIElements = *o;
			}
			pIElements->AddElement(wAddr,pElement);
		}
		else
		{
			if (m_bitNum > m_listIElements.size())
			{
				pIElements = new CIElement<TIElement>(1);
				pIElements->AddElement(wAddr,pElement);
				m_listIElements.push_back(pIElements);
			}
			else assert(false);
		}
	}
protected:
	bool			m_bSQ;
	BYTE			m_bitNum;
	vector<CIElement<TIElement>* >	m_listIElements;
};

template <class TIElement>
class CASDU
{
public:
	CASDU(BYTE* pbyData,WORD wSize)
	{
		FromBuf(pbyData,wSize);
	}
	CASDU(bool bIsSQ,BYTE byNum,BYTE byPubAddr,DataType dt,BYTE byReason,bool bTest,bool bP_N)
	{
		m_byPubAddr = byPubAddr;
		m_bitTest = bTest?1:0;
		m_bitP_N = bP_N?1:0;
		m_bitReason = byReason;
		m_datatype = dt;
		BYTE bySQ = (bIsSQ?0x80:0) | (byNum & 0x7f);
		SetSQ(bySQ);
	}
	BYTE ToBuf(BYTE * pBuf)
	{
		*pBuf++ = (BYTE)m_datatype;
		*pBuf++ = m_IElements.GetSQ();
		*pBuf++ = (BYTE)(m_bitTest<<7 + m_bitP_N<<6 + m_bitReason);
		*pBuf++ = m_byPubAddr;
		return  m_IElements.ToBuf(pBuf) + 4;
	}
	bool FromBuf(BYTE* pBuf,BYTE bySize)
	{
		bool bRet = false;
		if (bySize > 4)
		{
			m_datatype = (DataType)*pBuf++;
			m_IElements.SetSQ(*pBuf++);
			BYTE b = *pBuf++;
			m_bitTest = (b&0x80)>>7;
			m_bitP_N = (b&0x40)>>6;
			m_bitReason =b&0x3f;
			m_byPubAddr = *pBuf++;
			bRet = m_IElements.FromBuf(pBuf,bySize-4);
		}
		return bRet;
	}
	BYTE GetLen()
	{
		BYTE byRet = 4;
		byRet += m_IElements.GetLen();
		return byRet;
	}
	DataType	GetType() {return m_datatype;}
	bool	IsTest() {return (m_bitTest == 1)?true:false;}
	bool	IsP_N() {return (m_bitP_N == 1)?true:false;}
	BYTE	GetReason() {return m_bitReason;}
	void		SetReason(BYTE byReason) {m_bitReason = byReason;}
	BYTE	GetPubAddr() {return m_byPubAddr;}
	bool	IsSQ()
	{	
		BYTE b = m_IElements.GetSQ();
		bool bRet = ((b&0x80)==0x80) ? true : false;
		return bRet;
	}
	BYTE GetElementNum()
	{
		BYTE b = m_IElements.GetSQ();
		BYTE byRet = b&0x7f;
		return byRet;
	}
	void SetSQ(BYTE bySQ)
	{
		m_IElements.SetSQ(bySQ);
	}
	bool GetElement(BYTE byElementNo,WORD& wAddr,TIElement*& pElement)
	{
		return	m_IElements.GetElement(byElementNo,wAddr,pElement);
	}
	void AddElement(WORD wAddr,TIElement* pElement)
	{
		m_IElements.AddElement(wAddr,pElement);
	}
protected:
	DataType	m_datatype;
	BYTE		m_bitTest:1;
	BYTE		m_bitP_N:1;//<0>:肯定认可；<1>:否定认可
	BYTE		m_bitReason:6;
	BYTE		m_byPubAddr;
	CIElements<TIElement>	m_IElements;
};

};//end name space IEC8705101

#endif