msystem.h

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

#ifndef _MSYSTEM_H
#define _MSYSTEM_H

#include <string>
#include <list>
#include <vector>
#include <queue>
#include <iostream>
#include <string>
#include <map>
#include <set>
#include <algorithm>

#include <pthread.h>
#include <semaphore.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include <fcntl.h>
#include <assert.h>
#include <time.h>
#include <stdio.h>
#include <termios.h>


#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <stdlib.h>

#define _UC7400
//#define _DEBUGUC
//#define _COMMONITOR
//#define _VIRTUAL_COMM
#define _BACK
//#define _DEMO

//#define _DEBUG
//#define _DEBUGCHANNEL

//#define _DEBUGTEMP

#ifndef BYTE	
#define BYTE unsigned char
#endif

#ifndef WORD	
#define WORD unsigned short
#endif

#ifndef LONG
#define LONG long
#endif

#ifndef DWORD
#define DWORD unsigned long
#endif

#ifndef BOOL
#define BOOL bool
#endif

#ifndef NULL
#define NULL 0
#endif

#ifndef TRUE
#define TRUE true
#endif

#ifndef FALSE
#define FALSE false
#endif

WORD BTI(WORD wBCD);
BYTE BTI(BYTE byBCD);

using namespace std;

enum CID
{
	//数据库在线修改
	e_cidModifyDb		= 0x11,
	e_cidModifyDbYX		= 0x12,
	e_cidModifyDbYC		= 0x13,
	e_cidModifyDbZJTM	= 0x14,//总加、图名
	e_cidModifyDbYXAuto	= 0x15,//封锁、解锁
	e_cidModifyDbYCAuto	= 0x16,//封锁、解锁
	//图形、位图、图元、声音等文件在线修改
	e_cidModifyDVP = 0x21,
	e_cidModifyBMP = 0x22,
	e_cidModifyCMP = 0x23,
	e_cidModifyWAV = 0x24,
	e_cidModifyINI = 0x25,
	//曲线、报表的在线修改
	e_cidModifyRC= 0x31,
//	e_cidNotifyYK= 0x32,
	//故障确认
	e_cidKnowEvent = 0x41,
	//上发YC、YX、SOE、事件及自诊断信息
	e_cidUpYC = 0x51,
	e_cidUpYX = 0x52,
	e_cidUpSOE = 0x53,
	e_cidUpEvent = 0x54,
	e_cidUpDiag = 0x55,
	//下发YK、读定值、设定值、信号复归等命令
	e_cidDownYK = 0x61,
	e_cidDownGetFV = 0x62,
	e_cidDownSetFV = 0x63,
	e_cidDownReset = 0x64,
	e_cidAllStatus = 0x65,
	e_cidSOEMesage = 0x66,
	e_cidSetStatus = 0x67,
	e_cidAnswerStatus = 0x68,
	//上发命令回应
	e_cidUpCmdEcho = 0x71,
	e_cidUpRectifyTime = 0x72,
	e_cidSystemStatus = 0x73,
	//机器[通道]切换请求及回应
	e_cidAskAlter = 0x81,
	e_cidAnsAlter = 0x91,
};

enum cmd_echo {
	ce_eOK,ce_eFail,ce_eTimeout,ce_eInvalidCmd,ce_eOther
};

enum frame_check {
	fc_eNormal,fc_eCheckSum,fc_eCmdFormat,fc_eInvalidCmd,
	fc_eInvalidData,fc_eOperateFail,fc_eOther
};

const BYTE BROADCASTADDR = 0xff;

enum KINDOFDATALINK{
	kdl_eTA,	kdl_eWHGPS,	kdl_eISA,	kdl_eDDB,			kdl_eGZDZlp,
	kdl_eCDTs,	kdl_e1801s,		kdl_e1801,	kdl_eIEC8705101,	kdl_eSimu,		kdl_eCDTm,kdl_eCDT,
	kdl_eSepam2000,			kdl_ePM500,	kdl_eJDDY,		kdl_eGPS,		kdl_eDNP3,
	kdl_eJA05	,kdl_ePMAC,		kdl_eCSC2000,	kdl_eDATA86,	kdl_eYD2,	kdl_eBWD_3K130A,
	kdl_eSepam1000,kdl_eINTBUS
};

enum DevType {
	dt_eTAR200,	dt_eTAR200A,	dt_eTAR200C,	dt_eTAR200DC,
	dt_eTAL200,		dt_eDRQ,		dt_eBZT,		dt_eTAT210,		dt_eTAT211,
	dt_eCSC211,		dt_eCSC246,dt_ePMAC720,dt_ePM100EN,dt_ePMAC9900H,dt_ePMAC9900E,dt_ePMAC9900N,dt_ePMAC600B,dt_ePMAC303,dt_ePMAC503,dt_ePMAC600A,
	dt_eYD2010,   dt_eYD2100 ,dt_eYD2020,
	dt_eSEPAM20 = 20,	dt_eSEPAM40 = 40,
	dt_eREF542plus,dt_eWGK31001,dt_eJBK3000,dt_ePSME10,
	dt_eLDWKY,dt_eDCRJ,dt_ePA100CD,dt_ePA100MFZT,dt_ePA100JXZT,dt_ePA100,dt_ePMAC9900,dt_ePDM820,dt_ePDM803A,dt_eDDEF,dt_eDDEF1,
	dt_eFJTWKY, dt_eZGDWKY,dt_ePMAC503E,dt_ehlk2,dt_eTTC310,dt_eWKY0,dt_eGKJ0,dt_eSepam20_B21,dt_eSepam40_S40
};

class CTimeValSpan
{
public:
	CTimeValSpan()
	{
		m_lDays = 0;
		m_nHours = 0;
		m_nMins  = 0;
		m_nSecs = 0;
		m_lMicroSecs = 0;
	}
	CTimeValSpan(long lDays,int nHours,int nMins,int nSecs,long lMicroSecs=0)
	{
		m_lMicroSecs = lMicroSecs;
		m_nSecs = nSecs + m_lMicroSecs/1000;
		m_nMins  = nMins + m_nSecs/60;
		m_nHours = nHours + m_nMins/60;
		m_lDays = lDays + m_nHours/24;
		m_nHours %= 24;
		m_nMins %=60;
		m_nSecs %=60;
		m_lMicroSecs %=1000;
	}
	int GetMinute()
	{
		return m_nMins;
	}
	int GetASecs()
	{
		int nASecs = m_lDays*3600*24+m_nHours*3600+m_nMins*60+m_nSecs;
		return nASecs;
	}
	int GetMicroSecs()
	{
		return m_lMicroSecs;
	}
protected:
	long	m_lDays;
	int		m_nHours;
	int		m_nMins;
	int		m_nSecs;
	long	m_lMicroSecs; //微秒
friend class CTimeVal;
};

class CTimeVal
{
public:
	CTimeVal()
	{
		GetCurrentTime();
	}
	CTimeVal(timeval tv)
	{
		m_tv = tv;
	}
	CTimeVal(struct tm*  t,DWORD dwMicroSecs)
	{
		m_tv.tv_sec = mktime(t);
		m_tv.tv_usec = dwMicroSecs;
	}
	
	void SetTime()
	{
		settimeofday(&m_tv,NULL);
	}
	void GetTime(struct tm* time)
	{
		localtime_r(&m_tv.tv_sec, time);
	}
	void GetCurrentTime()
	{
		gettimeofday(&m_tv,NULL);
	}
	CTimeValSpan operator-(CTimeVal tv)
	{
		long secs = m_tv.tv_sec - tv.m_tv.tv_sec;
		long msecs = m_tv.tv_usec - tv.m_tv.tv_usec;
		if ((secs > 0) && (msecs <0))
		{
			secs--;
			msecs += 1000000;
		}
		else if ((secs < 0) && (msecs > 0))
		{
			secs++;
			msecs = msecs - 1000000;
		}
		CTimeValSpan tvsRet;
		tvsRet.m_lDays = secs/(24*3600);
		tvsRet.m_nHours = (secs%(24*3600))/3600;
		tvsRet.m_nMins = (secs%3600)/60;
		tvsRet.m_nSecs = secs%60;
		tvsRet.m_lMicroSecs = msecs;
		return tvsRet;		
	}
	void operator+=(CTimeValSpan tvs)
	{
		long l = m_tv.tv_usec + tvs.m_lMicroSecs;
		if (l >= 0)
		{
			m_tv.tv_usec = l%1000000;
			m_tv.tv_sec += tvs.m_lDays*24*3600+tvs.m_nHours*3600 + tvs.m_nMins*60 + tvs.m_nSecs + l/1000000;
		}
		else
		{
			m_tv.tv_usec = 1000000 + l%1000000;
			m_tv.tv_sec += tvs.m_lDays*24*3600+tvs.m_nHours*3600 + tvs.m_nMins*60 + tvs.m_nSecs + l/1000000 -1;
		}
	}
	bool operator<(CTimeVal tv)
	{
		bool bRet = false;
		if ((tv.m_tv.tv_sec > m_tv.tv_sec) ||
				((tv.m_tv.tv_sec == m_tv.tv_sec) && (tv.m_tv.tv_usec > m_tv.tv_usec)))
			bRet = true;
		return bRet;
	}
	bool operator>(CTimeVal tv)
	{
		bool bRet = false;
		if ((tv.m_tv.tv_sec < m_tv.tv_sec) ||
				((tv.m_tv.tv_sec == m_tv.tv_sec) && (tv.m_tv.tv_usec < m_tv.tv_usec)))
			bRet = true;
		return bRet;
	}
	void operator=(CTimeVal tv)
	{
		m_tv = tv.m_tv;
	}
	int GetMilliSecs()
	{
		return m_tv.tv_usec/1000;
	}
	int Get_usec()
	{
		return m_tv.tv_usec;
	}
	int Get_sec()
	{
		return m_tv.tv_sec;
	}
	BYTE GetAMSecs(WORD* pwBuf)
	{
		double l = (double)m_tv.tv_sec;
		double db= l*1000 + (m_tv.tv_usec /1000);
  		WORD aw1,aw2,aw3;
  		double db5= 0x10000;
  		db5 *= 0x10000;
	    	aw3 = (WORD)(db/db5);
    		db -= (double)aw3 * db5;
    		aw2 = (WORD)(db/0x10000);
    		db -= (double)aw2*0x10000;
    		aw1 = (WORD)db;
    		pwBuf[0] = aw1;
    		pwBuf[1] = aw2;
    		pwBuf[2] = aw3;
    		return 6;
	}
protected:
	timeval	m_tv;
};

#include "dataqueue.h"
//#include "DevMgr.h"
//#include "channelmgr.h"

class CDevFactor
{
public:
	CDevFactor(WORD wDevNo,WORD wDevPubAddr)
	{
		m_wDevNo = wDevNo;
		m_wDevPubAddr = wDevPubAddr;
	}
	bool operator<(CDevFactor df) const
	{
		bool bRet = false;
		if ((m_wDevNo < df.m_wDevNo)
				|| ((m_wDevNo == df.m_wDevNo) && (m_wDevPubAddr < df.m_wDevPubAddr)))
			bRet = true;
		return bRet;
	}
	bool operator==(CDevFactor df) const
	{
		bool bRet = false;
		if ((m_wDevNo == df.m_wDevNo) && (m_wDevPubAddr == df.m_wDevPubAddr))
			bRet = true;
		return bRet;
	}
protected:
	WORD	m_wDevNo; //=0: m_nType = YX ,系统信息
	WORD	m_wDevPubAddr;
};

class CFrame
{
public:
	CFrame()
	{
		m_bIsSetup = false;
		m_bStart = false;
	}
	virtual bool BufferToFrame(CDQue* pPhyDQ) = 0;
	virtual bool FrameToBuffer(CDataNode &dn) = 0;
	virtual void FrameToBuf(CFrameNode& fn) = 0;
	virtual void SetupFrame(CFrameNode *pFNSend) = 0;
	BYTE* GetDataPtr() {return m_pData;}
	WORD GetDataSize() {return m_wLength;}
	BYTE GetAddr() {return m_byAddr;}
	void Reset()
	{
		m_wLength = 0;
		m_bStart = false;
		m_wInLength = 0;
		m_bIsSetup = false;
	}
protected:
	BYTE	m_byAddr;
	BYTE	m_pData[256*6];
	WORD	m_wLength;
	bool	m_bIsSetup;
	bool	m_bStart;
	BYTE	m_pbyInBuf[256*6];
	WORD	m_wInLength;
};

struct YCData
{
	WORD	m_wDevNo;
	WORD	m_wDevPtNo;
	double	m_fValue;
};

struct YXData
{
	WORD	m_wDevNo;
	WORD	m_wDevPtNo;
	WORD	m_bValue;
};

struct DDData
{
	WORD	m_wDevNo;
	WORD	m_wDevPtNo;
	DWORD	m_dwValue;
};

struct SOEData
{
	WORD		m_wDevNo;
	WORD		m_wDevPtNo;
	WORD		m_bValue;
	CTimeVal	m_ctv;
};

struct SEPData //单个事件
{
	WORD		m_wDevPtNo;
	bool		m_bOn;
	WORD		m_wMilliSecs; //持续毫秒（0-59999）
	CTimeVal	m_ctv;		//绝对时间
};

struct SPEData //成组启动事件
{
	WORD		m_wDevPtNo;
	BYTE		m_byOn;
	WORD		m_wMilliSecs; //持续毫秒（0-59999）
	CTimeVal	m_ctv;		//绝对时间
};

struct OCIData //成组输出电路信息
{
	WORD		m_wDevPtNo;
	BYTE		m_byOn;
	WORD		m_wMilliSecs; //持续毫秒（0-59999）
	CTimeVal	m_ctv;		//绝对时间
};

enum FVType
{
	FV_eLmtTime/*限时*/,FV_eLP/*软压板*/,FV_eLmtValue/*限值*/
};

struct FVData
{
	int			m_nID;
	FVType		m_typeFV;
	union {
		WORD	m_wMilliSecs; //限时 毫秒（0-59999）
		bool	m_bOn; //压板
		short	m_shValue;
	};
};

enum VARENUM {
    VT_EMPTY = 0,
    VT_NULL = 1,
    VT_I2 = 2,
    VT_I4 = 3,
    VT_R4 = 4,
    VT_R8 = 5,
    VT_CY = 6,
    VT_DATE = 7,
    VT_BSTR = 8,
    VT_DISPATCH = 9,
    VT_ERROR = 10,
    VT_BOOL = 11,
    VT_VARIANT = 12,
    VT_UNKNOWN = 13,
    VT_DECIMAL = 14,
    VT_I1 = 16,
    VT_UI1 = 17,
    VT_UI2 = 18,
    VT_UI4 = 19,
    VT_I8 = 20,
    VT_UI8 = 21,
    VT_INT = 22,
    VT_UINT = 23,
    VT_VOID = 24,
    VT_HRESULT  = 25,
    VT_PTR = 26,
    VT_SAFEARRAY = 27,
    VT_CARRAY = 28,
    VT_USERDEFINED = 29,
    VT_LPSTR = 30,
    VT_LPWSTR = 31,
    VT_FILETIME = 64,
    VT_BLOB = 65,
    VT_STREAM = 66,
    VT_STORAGE = 67,
    VT_STREAMED_OBJECT = 68,
    VT_STORED_OBJECT = 69,
    VT_BLOB_OBJECT = 70,
    VT_CF = 71,
    VT_CLSID = 72,
    VT_VECTOR = 0x1000,
    VT_ARRAY = 0x2000,
    VT_BYREF = 0x4000,
    VT_RESERVED = 0x8000,
    VT_ILLEGAL = 0xffff,
    VT_ILLEGALMASKED = 0xfff,
    VT_TYPEMASK = 0xfff
};

struct struFVData
{
	WORD		m_dwID;
	WORD		m_vt;
	union {
		unsigned short	m_wValue;
		unsigned long	m_dwValue;
		short	m_shValue;
		long	m_nValue;
		BYTE m_bValue;
		float	m_fValue;
	};
};

/*
WORD CW(WORD w);
DWORD CDW(DWORD dw);
DWORD CHDW(DWORD dw);

WORD CW(BYTE byH,BYTE byL);
DWORD CDW(BYTE byHH,BYTE byH,BYTE byL,BYTE byLL);
*/
WORD CWFromBuf(BYTE*& pbyTemp);
DWORD CDWFromBuf(BYTE*& pbyTemp);

WORD CW(BYTE*& pbyTemp);
DWORD CDW(BYTE*& pbyTemp);
DWORD CHDW(BYTE*& pbyTemp);
DWORD CHDW2(BYTE*& pbyTemp);
void SW(WORD wValue,BYTE*& pbyBuf);
void SDW(DWORD dwValue,BYTE*& pbyBuf);
void SHDW(DWORD dwValue,BYTE*& pbyBuf);
/*
class CMDev
{
public:
	//ret -1:no send data; 0:no echo frame; 1:have echo frame
//	virtual int GetPeriod(CFrameNode& fn) = 0;
	//FixValue
	virtual int Read(WORD wDevNo,CFrameNode &FNSend) = 0;
	virtual int Write(WORD wDevNo,FVData* pData,WORD wCount,CFrameNode &FNSend) = 0;
	//byRoute = 0 : SingalReset;
	virtual int Select(WORD wDevNo,BYTE byRoute,bool bIsOn,CFrameNode &FNSend) = 0;
	virtual int Operate(WORD wDevNo,BYTE byRoute,bool bIsOn,CFrameNode &FNSend) = 0;
	virtual int SReset(WORD wDevNo,CFrameNode &FNSend) = 0;
	virtual int ExplainRESP(CFrameNode* pFNRecv,CFQue& FDQueSTD) = 0;
	virtual int GetOverTime() {return m_nOverTime;};
	virtual bool IsMyDev(WORD wDevNo) = 0;
protected:
	CMDev(CAllMgr* pAllMgr,int nOverTime)
	{
		m_pAllMgr = pAllMgr;
		m_nOverTime = nOverTime;
	}
	virtual ~CMDev(){}

	int			m_nOverTime;
	CAllMgr*	m_pAllMgr;

};

class CSDev
{
public:
	virtual void YC(WORD wDevNo,YCData* pYCValue,WORD wCount) = 0;
	virtual void YX(WORD wDevNo,YXData* pBoolValue,WORD wCount) = 0;
	virtual void DD(WORD wDevNo,DDData* pDDValue,WORD wCount) = 0;
	virtual void SOE(WORD wDevNo,SOEData* pSOEValue,WORD wCount) = 0;
	virtual void SEP(WORD wDevNo,SEPData* pSEPValue,WORD wCount) = 0; //保护、重合闸单个事件
	virtual void SPE(WORD wDevNo,SPEData* pSPEValue,WORD wCount) = 0; //保护启动
	virtual void OCI(WORD wDevNo,OCIData* pOCIValue,WORD wCount) = 0; //输出
	//from master
	virtual void YK(WORD wPubAddr,bool bOn) = 0;
	virtual void YT(WORD wPubAddr,bool bUp) = 0;
	virtual void Get(WORD wPubAddr,short shValue) = 0;
	virtual void Set(WORD wPubAddr,short shValue) = 0;
	virtual void BitStr(WORD wPubaddr,BYTE* pbyBitValue,WORD wCount) = 0;
	virtual void VerifyTime();
	virtual bool GetPRMData(CFQue&	FDQueSend) = 0;
	virtual void GetCycleData(CFQue&	FDQueSend) = 0;
protected:
	CSDev(CAllMgr* pAllMgr)
	{
		m_pAllMgr = pAllMgr;
	}
	virtual ~CSDev(){}
	
	CAllMgr*	m_pAllMgr;
};
*/

struct struLocal
{
	WORD wDevNo;
	WORD wLocalNo;
};

struct struReg
{
	WORD wArea;
	WORD wRegAddr;
	bool operator<(const struReg& other) const
	{
		bool bRet = false;
		if (wArea < other.wArea) bRet = true;
		else if ((wArea == other.wArea) && (wRegAddr < other.wRegAddr)) bRet = true;
		return bRet;
	}
	bool operator==(const struReg& other) const
	{
		return ((wArea == other.wArea) && (wRegAddr == other.wRegAddr));
	}
};

BYTE xor_(BYTE *puchMsg, BYTE usDataLen);

extern char g_szLocalAddr[16] ;
extern char g_szPeerAddr[16];
extern int g_nPort;

#endif