data_template.h

104规约从站库源代码

	
//========================================================================================
protected:
	
	_int linkerbuffsize;
//	HANDLE datamutex;
//	HANDLE qualmutex;
	HANDLE SP_NA_datamutex;
	HANDLE DP_NA_datamutex;
	HANDLE ST_NA_datamutex;
	HANDLE ST_TA_datamutex;
	HANDLE PS_NA_datamutex;
	HANDLE BO_NA_datamutex;
	HANDLE BO_TA_datamutex;
	HANDLE SP_TA_datamutex;
	HANDLE DP_TA_datamutex;
	HANDLE ME_NA_datamutex;
	HANDLE ME_ND_datamutex;

	HANDLE ME_TA_datamutex;
	HANDLE ME_TB_datamutex;
	HANDLE ME_TC_datamutex;
	HANDLE ME_NB_datamutex;
	HANDLE ME_NC_datamutex;
	HANDLE EP_TA_datamutex;
	HANDLE EP_TB_datamutex;
	HANDLE EP_TC_datamutex;

	HANDLE P_ME_NA_datamutex;
	HANDLE P_ME_NB_datamutex;
	HANDLE P_ME_NC_datamutex;

	HANDLE IT_NA_datamutex;
	void waitfordatamutex(HANDLE datamutex)
	{
		WaitForSingleObject(datamutex,0xFFFFFFFF);
	};
	void releasedatamutex(HANDLE datamutex)
	{	
		ReleaseMutex(datamutex);
	};
	void waitforqualmutex()
	{
	
	};
	void releasequalmutex()
	{
	
	};
	void initdatamutex()
	{
	SP_NA_datamutex=CreateMutex(NULL,FALSE,NULL);
	PS_NA_datamutex=CreateMutex(NULL,FALSE,NULL);
	BO_NA_datamutex=CreateMutex(NULL,FALSE,NULL);
	BO_TA_datamutex=CreateMutex(NULL,FALSE,NULL);

	ST_NA_datamutex=CreateMutex(NULL,FALSE,NULL);
	ST_TA_datamutex=CreateMutex(NULL,FALSE,NULL);
	
	DP_NA_datamutex=CreateMutex(NULL,FALSE,NULL);
	SP_TA_datamutex=CreateMutex(NULL,FALSE,NULL);
	DP_TA_datamutex=CreateMutex(NULL,FALSE,NULL);
	ME_NA_datamutex=CreateMutex(NULL,FALSE,NULL);
	ME_ND_datamutex=CreateMutex(NULL,FALSE,NULL);

	ME_TA_datamutex=CreateMutex(NULL,FALSE,NULL);
	ME_TB_datamutex=CreateMutex(NULL,FALSE,NULL);
	ME_TC_datamutex=CreateMutex(NULL,FALSE,NULL);
	ME_NB_datamutex=CreateMutex(NULL,FALSE,NULL);
	ME_NC_datamutex=CreateMutex(NULL,FALSE,NULL);
	EP_TA_datamutex=CreateMutex(NULL,FALSE,NULL);
	EP_TB_datamutex=CreateMutex(NULL,FALSE,NULL);
	EP_TC_datamutex=CreateMutex(NULL,FALSE,NULL);

	P_ME_NA_datamutex=CreateMutex(NULL,FALSE,NULL);
	P_ME_NB_datamutex=CreateMutex(NULL,FALSE,NULL);
	P_ME_NC_datamutex=CreateMutex(NULL,FALSE,NULL);

	IT_NA_datamutex=CreateMutex(NULL,FALSE,NULL);
	};
	void initqualmutex()
	{
	};
	
	void closedatamutex()
	{
		CloseHandle( PS_NA_datamutex);
		CloseHandle( BO_NA_datamutex);
		CloseHandle( SP_NA_datamutex);
		CloseHandle( DP_NA_datamutex);
		CloseHandle( SP_TA_datamutex);
		CloseHandle( BO_TA_datamutex);
		CloseHandle( DP_TA_datamutex);
		CloseHandle( ME_NA_datamutex);
		CloseHandle( ME_ND_datamutex);
		CloseHandle( ME_NB_datamutex);
		CloseHandle( ME_NC_datamutex);
		CloseHandle( ME_TA_datamutex);
		CloseHandle( EP_TA_datamutex);
		CloseHandle( EP_TB_datamutex);
		CloseHandle( EP_TC_datamutex);

		CloseHandle( ME_TB_datamutex);
		CloseHandle( ME_TC_datamutex);
		CloseHandle( P_ME_NA_datamutex);
		CloseHandle( P_ME_NB_datamutex);
		CloseHandle( P_ME_NC_datamutex);
		CloseHandle( IT_NA_datamutex);

	};
	void closequalmutex()
	{
	};
//=========================================================================
public:	
	void SP_NA_ResetDataflag();
	_int SP_NA_GetSpecialFrame(_BYTE* buff);
//	_int SP_NA_GetSpecialPSFrame(_BYTE* buff);
//	_int SP_NA_GetSpontPSFrame(_BYTE* buff);
	_int SP_NA_GetEventFrame(_BYTE* buff);//
	_int SP_NA_GetReqcallFrame(_BYTE* buff,_BYTE group);//0 :Total   1:group1 .....

	_int SP_NA_GetBackgroundFrame(_BYTE* buff);
	_int SP_NA_GetCycleFrame(_BYTE* buff);
	bool SP_NA_ScanSpecialSpontFlag();
//	bool SP_NA_ScanSpontPSFlag();
//	bool SP_NA_ScanSpecialPSFlag();
	bool SP_NA_ScanEventSpontFlag();
	
	bool SP_NA_ScanReqcallFlag(_BYTE group);
	bool SP_NA_ScanCycleFlag();
	bool SP_NA_ScanBackFlag();
	void SP_NA_SetData(_int index, TP_SINGLE_POINT * value);

	TP_SINGLE_POINT SP_NA_GetData(_int index);
	TP_SINGLE_POINT SP_NA_viewdata(_int index);
	TP_SINGLE_POINT SP_NA_GetOldData(_int index);
	//IV: 0有效/1无效   NT:0当前值/1非当前   SB:0未取代/1被取代  BL:0未被闭锁/1闭锁   OV:1溢出/ 0:不溢出
	void SP_NA_SetQuality(_int index,_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);

	void SP_NA_GetQuality(_int index,_BYTE *IV,_BYTE *NT,_BYTE *SB,_BYTE *BL,_BYTE *OV);
	_BYTE SP_NA_GetByteQuality(_int index);
	bool SP_NA_ScanQualityChange();
public:
	bool SP_NA_judgeDatachangeflag(_int index,TP_SINGLE_POINT *value);
	ASDU_ATTRI SP_NA_asdu_attri[Data_SP_NA_COUNTS_MAX];
	
	_int SP_NA_SpontPSPtr;
	_int SP_NA_SpecialPSPtr;
	_int SP_NA_SpecialSpontPtr;
	_int SP_NA_SpontPtr;

	_int SP_NA_ReqcallPtr;
	bool SP_NA_Reqcallflag;
	_int SP_NA_CyclescanPtr;
	bool SP_NA_Cycleflag;
	_int SP_NA_BackgroundPtr;
	bool SP_NA_Backflag;

	TP_SINGLE_POINT SP_NA_data_val[Data_SP_NA_COUNTS_MAX ];
	TP_SINGLE_POINT SP_NA_data_old_val[Data_SP_NA_COUNTS_MAX ];
	_BYTE SP_NA_data_quality[Data_SP_NA_COUNTS_MAX ];
	_BYTE SP_NA_data_old_quality[Data_SP_NA_COUNTS_MAX ];
	_BYTE  SP_NA_changeflag[Data_SP_NA_COUNTS_MAX ];
	bool  SP_NA_changequalflag[Data_SP_NA_COUNTS_MAX ];
	_BYTE SP_NA_SpecialCOT[Data_SP_NA_COUNTS_MAX ];
//================================================================================
public:	
	bool SP_TA_IsEmpty();
	_int SP_TA_GetCounts();
	_int SP_TA_GetdispPtr();
	bool SP_TA_AddOneRecorder();
	bool SP_TA_GetFirstRecorder();
	bool SP_TA_RemoveOneRecorder();
	
	
	void SP_TA_SetDataIndex(_WORD index);
		

	void SP_TA_SetData(TP_SINGLE_POINT *value);//Note: index-->infobodyaddr 
	void SP_TA_SetCOT(_BYTE cot);//Note: index-->infobodyaddr 
	void SP_TA_SetTimeTag(TIME_STRU *value);//Note: index-->infobodyaddr 
	void SP_TA_SetQuality(_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);
	
	void SP_TA_ResetDataflag();
	_int SP_TA_GetEventFrame(_BYTE* buff);//
	_int SP_TB_GetEventFrame(_BYTE* buff);//
	bool SP_TA_ScanEventSpontFlag();

	typedef struct SP_TA_Seqstru
	{
		_BYTE SpecialCOT;
		_WORD		index;//
		TIME_STRU	timetag;
		TP_SINGLE_POINT		data_val;
		_BYTE		data_quality;
	} 	SP_TA_SEQ_STRU;
	void SP_TA_dispStore(SP_TA_SEQ_STRU *soe);
public:
	SP_TA_SEQ_STRU SP_TA_SeqNode;
	SP_TA_SEQ_STRU SP_TA_dispBuf[Data_SP_TA_dispCOUNTS];
	_int SP_TA_dispPtr;
	SP_TA_SEQ_STRU SP_TA_seqlist[Data_SP_TA_COUNTS];
	_WORD SP_TA_counter;
	
//=======================================================================
//Double
	void DP_NA_ResetDataflag();
	_int DP_NA_GetSpecialFrame(_BYTE* buff);
//	_int DP_NA_GetSpecialPSFrame(_BYTE* buff);
//	_int DP_NA_GetSpontPSFrame(_BYTE* buff);
	_int DP_NA_GetEventFrame(_BYTE* buff);//
	_int DP_NA_GetReqcallFrame(_BYTE* buff,_BYTE group);//0 :Total   1:group1 .....

	_int DP_NA_GetBackgroundFrame(_BYTE* buff);
	_int DP_NA_GetCycleFrame(_BYTE* buff);
	bool DP_NA_ScanSpecialSpontFlag();
//	bool DP_NA_ScanSpontPSFlag();
//	bool DP_NA_ScanSpecialPSFlag();
	bool DP_NA_ScanEventSpontFlag();
	
	bool DP_NA_ScanReqcallFlag(_BYTE group);
	bool DP_NA_ScanCycleFlag();
	bool DP_NA_ScanBackFlag();
	void DP_NA_SetData(_int index, TP_DOUBLE_POINT * value);

	TP_DOUBLE_POINT DP_NA_GetData(_int index);
	TP_DOUBLE_POINT DP_NA_viewdata(_int index);
	TP_DOUBLE_POINT DP_NA_GetOldData(_int index);
	//IV: 0有效/1无效   NT:0当前值/1非当前   SB:0未取代/1被取代  BL:0未被闭锁/1闭锁   OV:1溢出/ 0:不溢出
	void DP_NA_SetQuality(_int index,_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);

	void DP_NA_GetQuality(_int index,_BYTE *IV,_BYTE *NT,_BYTE *SB,_BYTE *BL,_BYTE *OV);
	_BYTE DP_NA_GetByteQuality(_int index);
	bool DP_NA_ScanQualityChange();
public:
	bool DP_NA_judgeDatachangeflag(_int index,TP_DOUBLE_POINT *value);
	ASDU_ATTRI DP_NA_asdu_attri[Data_DP_NA_COUNTS_MAX];
	
	_int DP_NA_SpontPSPtr;
	_int DP_NA_SpecialPSPtr;
	_int DP_NA_SpecialSpontPtr;
	_int DP_NA_SpontPtr;

	_int DP_NA_ReqcallPtr;
	bool DP_NA_Reqcallflag;
	_int DP_NA_CyclescanPtr;
	bool DP_NA_Cycleflag;
	_int DP_NA_BackgroundPtr;
	bool DP_NA_Backflag;

	TP_DOUBLE_POINT DP_NA_data_val[Data_DP_NA_COUNTS_MAX ];
	TP_DOUBLE_POINT DP_NA_data_old_val[Data_DP_NA_COUNTS_MAX ];
	_BYTE DP_NA_data_quality[Data_DP_NA_COUNTS_MAX ];
	_BYTE DP_NA_data_old_quality[Data_DP_NA_COUNTS_MAX ];
	_BYTE  DP_NA_changeflag[Data_DP_NA_COUNTS_MAX ];
	bool  DP_NA_changequalflag[Data_DP_NA_COUNTS_MAX ];
	_BYTE DP_NA_SpecialCOT[Data_DP_NA_COUNTS_MAX ];
//============================================================================
	bool DP_TA_IsEmpty();
	_int DP_TA_GetCounts();
	_int DP_TA_GetdispPtr();
	bool DP_TA_AddOneRecorder();
	bool DP_TA_GetFirstRecorder();
	bool DP_TA_RemoveOneRecorder();
	
	
	void DP_TA_SetDataIndex(_WORD index);
		

	void DP_TA_SetData(TP_DOUBLE_POINT *value);//Note: index-->infobodyaddr 
	void DP_TA_SetCOT(_BYTE cot);//Note: index-->infobodyaddr 
	void DP_TA_SetTimeTag(TIME_STRU *value);//Note: index-->infobodyaddr 
	void DP_TA_SetQuality(_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);
	
	void DP_TA_ResetDataflag();
	_int DP_TA_GetEventFrame(_BYTE* buff);//
	_int DP_TB_GetEventFrame(_BYTE* buff);
	
	bool DP_TA_ScanEventSpontFlag();

	typedef struct DP_TA_Seqstru
	{
		_BYTE SpecialCOT;
		_WORD		index;//
		TIME_STRU	timetag;
		TP_DOUBLE_POINT		data_val;
		_BYTE		data_quality;
	} 	DP_TA_SEQ_STRU;
	void DP_TA_dispStore(DP_TA_SEQ_STRU *soe);
public:
	DP_TA_SEQ_STRU DP_TA_SeqNode;
	DP_TA_SEQ_STRU DP_TA_dispBuf[Data_DP_TA_dispCOUNTS];
	_int DP_TA_dispPtr;
	DP_TA_SEQ_STRU DP_TA_seqlist[Data_DP_TA_COUNTS];
	_WORD DP_TA_counter;
	
//================================================================================
	public:	
	void PS_NA_ResetDataflag();
	_int PS_NA_GetSpecialFrame(_BYTE* buff);
	_int PS_NA_GetEventFrame(_BYTE* buff);//
	_int PS_NA_GetReqcallFrame(_BYTE* buff,_BYTE group);//0 :Total   1:group1 .....

	_int PS_NA_GetBackgroundFrame(_BYTE* buff);
	_int PS_NA_GetCycleFrame(_BYTE* buff);
	bool PS_NA_ScanSpecialSpontFlag();
	bool PS_NA_ScanEventSpontFlag();
	
	bool PS_NA_ScanReqcallFlag(_BYTE group);
	bool PS_NA_ScanCycleFlag();
	bool PS_NA_ScanBackFlag();
	void PS_NA_SetData(_int index, TP_DWPS_POINT * value);

	TP_DWPS_POINT PS_NA_GetData(_int index);
	TP_DWPS_POINT PS_NA_viewdata(_int index);
	TP_DWPS_POINT PS_NA_GetOldData(_int index);
	//IV: 0有效/1无效   NT:0当前值/1非当前   SB:0未取代/1被取代  BL:0未被闭锁/1闭锁   OV:1溢出/ 0:不溢出
	void PS_NA_SetQuality(_int index,_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);

	void PS_NA_GetQuality(_int index,_BYTE *IV,_BYTE *NT,_BYTE *SB,_BYTE *BL,_BYTE *OV);
	_BYTE PS_NA_GetByteQuality(_int index);
	bool PS_NA_ScanQualityChange();
public:
	bool PS_NA_judgeDatachangeflag(_int index,TP_DWPS_POINT *value);
	ASDU_ATTRI PS_NA_asdu_attri[Data_PS_NA_COUNTS_MAX];
	
	_int PS_NA_SpontPSPtr;
	_int PS_NA_SpecialPSPtr;
	_int PS_NA_SpecialSpontPtr;
	_int PS_NA_SpontPtr;

	_int PS_NA_ReqcallPtr;
	bool PS_NA_Reqcallflag;
	_int PS_NA_CyclescanPtr;
	bool PS_NA_Cycleflag;
	_int PS_NA_BackgroundPtr;
	bool PS_NA_Backflag;

	TP_DWPS_POINT PS_NA_data_val[Data_PS_NA_COUNTS_MAX ];
	TP_DWPS_POINT PS_NA_data_old_val[Data_PS_NA_COUNTS_MAX ];
	_BYTE PS_NA_data_quality[Data_PS_NA_COUNTS_MAX ];
	_BYTE PS_NA_data_old_quality[Data_PS_NA_COUNTS_MAX ];
	_BYTE  PS_NA_changeflag[Data_PS_NA_COUNTS_MAX ];
	bool  PS_NA_changequalflag[Data_PS_NA_COUNTS_MAX ];
	_BYTE PS_NA_SpecialCOT[Data_PS_NA_COUNTS_MAX ];
//=========================================================================
public:	
	void ST_NA_ResetDataflag();
	_int ST_NA_GetSpecialFrame(_BYTE* buff);
//	_int ST_NA_GetSpecialPSFrame(_BYTE* buff);
//	_int ST_NA_GetSpontPSFrame(_BYTE* buff);
	_int ST_NA_GetEventFrame(_BYTE* buff);//
	_int ST_NA_GetReqcallFrame(_BYTE* buff,_BYTE group);//0 :Total   1:group1 .....

	_int ST_NA_GetBackgroundFrame(_BYTE* buff);
	_int ST_NA_GetCycleFrame(_BYTE* buff);
	bool ST_NA_ScanSpecialSpontFlag();
//	bool ST_NA_ScanSpontPSFlag();
//	bool ST_NA_ScanSpecialPSFlag();
	bool ST_NA_ScanEventSpontFlag();
	
	bool ST_NA_ScanReqcallFlag(_BYTE group);
	bool ST_NA_ScanCycleFlag();
	bool ST_NA_ScanBackFlag();
	void ST_NA_SetData(_int index, TP_BYST_POINT * value);

	TP_BYST_POINT ST_NA_GetData(_int index);
	TP_BYST_POINT ST_NA_viewdata(_int index);
	TP_BYST_POINT ST_NA_GetOldData(_int index);
	//IV: 0有效/1无效   NT:0当前值/1非当前   SB:0未取代/1被取代  BL:0未被闭锁/1闭锁   OV:1溢出/ 0:不溢出
	void ST_NA_SetQuality(_int index,_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);

	void ST_NA_GetQuality(_int index,_BYTE *IV,_BYTE *NT,_BYTE *SB,_BYTE *BL,_BYTE *OV);
	_BYTE ST_NA_GetByteQuality(_int index);
	bool ST_NA_ScanQualityChange();
public:
	bool ST_NA_judgeDatachangeflag(_int index,TP_BYST_POINT *value);
	ASDU_ATTRI ST_NA_asdu_attri[Data_ST_NA_COUNTS_MAX];
	
	_int ST_NA_SpontPSPtr;
	_int ST_NA_SpecialPSPtr;
	_int ST_NA_SpecialSpontPtr;
	_int ST_NA_SpontPtr;

	_int ST_NA_ReqcallPtr;
	bool ST_NA_Reqcallflag;
	_int ST_NA_CyclescanPtr;
	bool ST_NA_Cycleflag;
	_int ST_NA_BackgroundPtr;
	bool ST_NA_Backflag;

	TP_BYST_POINT ST_NA_data_val[Data_ST_NA_COUNTS_MAX ];
	TP_BYST_POINT ST_NA_data_old_val[Data_ST_NA_COUNTS_MAX ];
	_BYTE ST_NA_data_quality[Data_ST_NA_COUNTS_MAX ];
	_BYTE ST_NA_data_old_quality[Data_ST_NA_COUNTS_MAX ];
	_BYTE  ST_NA_changeflag[Data_ST_NA_COUNTS_MAX ];
	bool  ST_NA_changequalflag[Data_ST_NA_COUNTS_MAX ];
	_BYTE ST_NA_SpecialCOT[Data_ST_NA_COUNTS_MAX ];
//================================================================================
//================================================================================
public:	
	bool ST_TA_IsEmpty();
	_int ST_TA_GetCounts();
	_int ST_TA_GetdispPtr();
	bool ST_TA_AddOneRecorder();
	bool ST_TA_GetFirstRecorder();
	bool ST_TA_RemoveOneRecorder();
	
	
	void ST_TA_SetDataIndex(_WORD index);
		

	void ST_TA_SetData(TP_BYST_POINT *value);//Note: index-->infobodyaddr 
	void ST_TA_SetCOT(_BYTE cot);//Note: index-->infobodyaddr 
	void ST_TA_SetTimeTag(TIME_STRU *value);//Note: index-->infobodyaddr 
	void ST_TA_SetQuality(_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);
	
	void ST_TA_ResetDataflag();
	_int ST_TA_GetEventFrame(_BYTE* buff);//
	_int ST_TB_GetEventFrame(_BYTE* buff);//
	bool ST_TA_ScanEventSpontFlag();
	void TagToDescr(_BYTE Tag,_char *TagDescr);
	void COTtoDescr(_BYTE COT,_char *cotDescr);


	typedef struct ST_TA_Seqstru
	{
		_BYTE SpecialCOT;
		_WORD		index;//
		TIME_STRU	timetag;
		TP_BYST_POINT		data_val;
		_BYTE		data_quality;
	} 	ST_TA_SEQ_STRU;
	void ST_TA_dispStore(ST_TA_SEQ_STRU *soe);
public:
	ST_TA_SEQ_STRU ST_TA_SeqNode;
	ST_TA_SEQ_STRU ST_TA_dispBuf[Data_ST_TA_dispCOUNTS];
	_int ST_TA_dispPtr;
	ST_TA_SEQ_STRU ST_TA_seqlist[Data_ST_TA_COUNTS];
	_WORD ST_TA_counter;
	
//=======================================================================
//================================================================================
	public:	
	void BO_NA_ResetDataflag();
	_int BO_NA_GetEventFrame(_BYTE* buff);//
	_int BO_NA_GetReqcallFrame(_BYTE* buff,_BYTE group);//0 :Total   1:group1 .....

	_int BO_NA_GetBackgroundFrame(_BYTE* buff);
	_int BO_NA_GetCycleFrame(_BYTE* buff);
	bool BO_NA_ScanEventSpontFlag();
	
	bool BO_NA_ScanReqcallFlag(_BYTE group);
	bool BO_NA_ScanCycleFlag();
	bool BO_NA_ScanBackFlag();
	void BO_NA_SetData(_int index, TP_BO_NA * value);