data_template.h

104规约从站库源代码

	TP_BO_NA BO_NA_GetData(_int index);
	TP_BO_NA BO_NA_viewdata(_int index);
	TP_BO_NA BO_NA_GetOldData(_int index);
	//IV: 0有效/1无效   NT:0当前值/1非当前   SB:0未取代/1被取代  BL:0未被闭锁/1闭锁   OV:1溢出/ 0:不溢出
	void BO_NA_SetQuality(_int index,_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);

	void BO_NA_GetQuality(_int index,_BYTE *IV,_BYTE *NT,_BYTE *SB,_BYTE *BL,_BYTE *OV);
	_BYTE BO_NA_GetByteQuality(_int index);
	bool BO_NA_ScanQualityChange();
public:
	bool BO_NA_judgeDatachangeflag(_int index,TP_BO_NA *value);
	ASDU_ATTRI BO_NA_asdu_attri[Data_BO_NA_COUNTS_MAX];
	
	_int BO_NA_SpontPSPtr;
	_int BO_NA_SpecialPSPtr;
	_int BO_NA_SpecialSpontPtr;
	_int BO_NA_SpontPtr;

	_int BO_NA_ReqcallPtr;
	bool BO_NA_Reqcallflag;
	_int BO_NA_CyclescanPtr;
	bool BO_NA_Cycleflag;
	_int BO_NA_BackgroundPtr;
	bool BO_NA_Backflag;

	TP_BO_NA BO_NA_data_val[Data_BO_NA_COUNTS_MAX ];
	TP_BO_NA BO_NA_data_old_val[Data_BO_NA_COUNTS_MAX ];
	_BYTE BO_NA_data_quality[Data_BO_NA_COUNTS_MAX ];
	_BYTE BO_NA_data_old_quality[Data_BO_NA_COUNTS_MAX ];
	_BYTE  BO_NA_changeflag[Data_BO_NA_COUNTS_MAX ];
	bool  BO_NA_changequalflag[Data_BO_NA_COUNTS_MAX ];
	_BYTE BO_NA_SpecialCOT[Data_BO_NA_COUNTS_MAX ];
//=========================================================================
//================================================================================
public:	
	bool BO_TA_IsEmpty();
	_int BO_TA_GetCounts();
	_int BO_TA_GetdispPtr();
	bool BO_TA_AddOneRecorder();
	bool BO_TA_GetFirstRecorder();
	bool BO_TA_RemoveOneRecorder();
	
	
	void BO_TA_SetDataIndex(_WORD index);
		

	void BO_TA_SetData(TP_BO_NA *value);//Note: index-->infobodyaddr 
	void BO_TA_SetCOT(_BYTE cot);//Note: index-->infobodyaddr 
	void BO_TA_SetTimeTag(TIME_STRU *value);//Note: index-->infobodyaddr 
	void BO_TA_SetQuality(_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);
	
	void BO_TA_ResetDataflag();
	_int BO_TA_GetEventFrame(_BYTE* buff);//
	_int BO_TB_GetEventFrame(_BYTE* buff);//
	bool BO_TA_ScanEventSpontFlag();

	typedef struct BO_TA_Seqstru
	{
		_BYTE SpecialCOT;
		_WORD		index;//
		TIME_STRU	timetag;
		TP_BO_NA		data_val;
		_BYTE		data_quality;
	} 	BO_TA_SEQ_STRU;
	void BO_TA_dispStore(BO_TA_SEQ_STRU *soe);
public:
	BO_TA_SEQ_STRU BO_TA_SeqNode;
	BO_TA_SEQ_STRU BO_TA_dispBuf[Data_BO_TA_dispCOUNTS];
	_int BO_TA_dispPtr;
	BO_TA_SEQ_STRU BO_TA_seqlist[Data_BO_TA_COUNTS];
	_WORD BO_TA_counter;
	
//=======================================================================
public:	

	void ME_ND_ResetDataflag();
	_int ME_ND_GetEventFrame(_BYTE* buff);//
	_int ME_ND_GetReqcallFrame(_BYTE* buff,_BYTE group);
	_int ME_ND_GetBackgroundFrame(_BYTE* buff);
	_int ME_ND_GetCycleFrame(_BYTE* buff);
	bool ME_ND_ScanEventSpontFlag();
	bool ME_ND_ScanReqcallFlag(_BYTE group);
	bool ME_ND_ScanCycleFlag();
	bool ME_ND_ScanBackFlag();
	void ME_ND_SetData(_int index, TP_ME_NA * value);
	void ME_ND_SetDeadBand(_int index,TP_ME_NA deadband);
	TP_ME_NA   ME_ND_GetDeadBand(_int index);
	TP_ME_NA	ME_ND_GetData(_int index);
	TP_ME_NA	ME_ND_viewdata(_int index);
	TP_ME_NA	ME_ND_GetOldData(_int index);
	//IV: 0有效/1无效   NT:0当前值/1非当前   SB:0未取代/1被取代  BL:0未被闭锁/1闭锁   OV:1溢出/ 0:不溢出
	void ME_ND_SetQuality(_int index,_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);

	void ME_ND_GetQuality(_int index,_BYTE *IV,_BYTE *NT,_BYTE *SB,_BYTE *BL,_BYTE *OV);
	_BYTE ME_ND_GetByteQuality(_int index);
	bool ME_ND_ScanQualityChange();
	void ME_ND_SetToPara();
public:
	bool ME_ND_judgeDatachangeflag(_int index,TP_ME_NA *value);
	ASDU_ATTRI ME_ND_asdu_attri[Data_ME_ND_COUNTS_MAX ];
	//TP_ME_NA	ME_ND_deadband[Data_ME_ND_COUNTS];
	_int ME_ND_valveptr[Data_ME_ND_COUNTS_MAX ];
	_int ME_ND_highlimit[Data_ME_ND_COUNTS_MAX ];
	_int ME_ND_lowlimit[Data_ME_ND_COUNTS_MAX ];
	

	_int ME_ND_SpecialSpontPtr;
	_int ME_ND_SpontPtr;
	_int ME_ND_ReqcallPtr;
	_int ME_ND_CyclescanPtr;
	_int ME_ND_BackgroundPtr;
	bool ME_ND_Reqcallflag;
	bool ME_ND_Cycleflag;
	bool ME_ND_Backflag;

	TP_ME_NA	ME_ND_data_val[Data_ME_ND_COUNTS_MAX ];
	TP_ME_NA	ME_ND_data_old_val[Data_ME_ND_COUNTS_MAX ];
	_BYTE		ME_ND_data_quality[Data_ME_ND_COUNTS_MAX ];
	_BYTE		ME_ND_data_old_quality[Data_ME_ND_COUNTS_MAX ];
	bool		ME_ND_changeflag[Data_ME_ND_COUNTS_MAX ];
	bool		ME_ND_changequalflag[Data_ME_ND_COUNTS_MAX ];
	_BYTE		ME_ND_specialCOT[Data_ME_ND_COUNTS_MAX ];
//=================================================================================================

//================================================================================
public:	

	void ME_NA_ResetDataflag();
	_int ME_NA_GetEventFrame(_BYTE* buff);//
	_int ME_NA_GetReqcallFrame(_BYTE* buff,_BYTE group);
	_int ME_NA_GetBackgroundFrame(_BYTE* buff);
	_int ME_NA_GetCycleFrame(_BYTE* buff);
	bool ME_NA_ScanEventSpontFlag();
	bool ME_NA_ScanReqcallFlag(_BYTE group);
	bool ME_NA_ScanCycleFlag();
	bool ME_NA_ScanBackFlag();
	void ME_NA_SetData(_int index, TP_ME_NA * value);
	void ME_NA_SetDeadBand(_int index,TP_ME_NA deadband);
	TP_ME_NA   ME_NA_GetDeadBand(_int index);
	TP_ME_NA	ME_NA_GetData(_int index);
	TP_ME_NA	ME_NA_viewdata(_int index);
	TP_ME_NA	ME_NA_GetOldData(_int index);
	//IV: 0有效/1无效   NT:0当前值/1非当前   SB:0未取代/1被取代  BL:0未被闭锁/1闭锁   OV:1溢出/ 0:不溢出
	void ME_NA_SetQuality(_int index,_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);

	void ME_NA_GetQuality(_int index,_BYTE *IV,_BYTE *NT,_BYTE *SB,_BYTE *BL,_BYTE *OV);
	_BYTE ME_NA_GetByteQuality(_int index);
	bool ME_NA_ScanQualityChange();
	void ME_NA_SetToPara();
public:
	bool ME_NA_judgeDatachangeflag(_int index,TP_ME_NA *value);
	ASDU_ATTRI ME_NA_asdu_attri[Data_ME_NA_COUNTS_MAX ];
	//TP_ME_NA	ME_NA_deadband[Data_ME_NA_COUNTS];
	_int ME_NA_valveptr[Data_ME_NA_COUNTS_MAX ];
	_int ME_NA_highlimit[Data_ME_NA_COUNTS_MAX ];
	_int ME_NA_lowlimit[Data_ME_NA_COUNTS_MAX ];
	

	_int ME_NA_SpecialSpontPtr;
	_int ME_NA_SpontPtr;
	_int ME_NA_ReqcallPtr;
	_int ME_NA_CyclescanPtr;
	_int ME_NA_BackgroundPtr;
	bool ME_NA_Reqcallflag;
	bool ME_NA_Cycleflag;
	bool ME_NA_Backflag;

	TP_ME_NA	ME_NA_data_val[Data_ME_NA_COUNTS_MAX ];
	TP_ME_NA	ME_NA_data_old_val[Data_ME_NA_COUNTS_MAX ];
	_BYTE		ME_NA_data_quality[Data_ME_NA_COUNTS_MAX ];
	_BYTE		ME_NA_data_old_quality[Data_ME_NA_COUNTS_MAX ];
	bool		ME_NA_changeflag[Data_ME_NA_COUNTS_MAX ];
	bool		ME_NA_changequalflag[Data_ME_NA_COUNTS_MAX ];
	_BYTE		ME_NA_specialCOT[Data_ME_NA_COUNTS_MAX ];
//=================================================================================================
public:	

	void ME_NB_ResetDataflag();
	_int ME_NB_GetEventFrame(_BYTE* buff);//
	_int ME_NB_GetReqcallFrame(_BYTE* buff,_BYTE group);
	_int ME_NB_GetBackgroundFrame(_BYTE* buff);
	_int ME_NB_GetCycleFrame(_BYTE* buff);
	bool ME_NB_ScanEventSpontFlag();
	bool ME_NB_ScanReqcallFlag(_BYTE group);
	bool ME_NB_ScanCycleFlag();
	bool ME_NB_ScanBackFlag();
	void ME_NB_SetData(_int index, TP_ME_NB * value);
	void ME_NB_SetDeadBand(_int index,TP_ME_NB deadband);
	TP_ME_NB   ME_NB_GetDeadBand(_int index);
	TP_ME_NB	ME_NB_GetData(_int index);
	TP_ME_NB	ME_NB_viewdata(_int index);
	TP_ME_NB	ME_NB_GetOldData(_int index);
	//IV: 0有效/1无效   NT:0当前值/1非当前   SB:0未取代/1被取代  BL:0未被闭锁/1闭锁   OV:1溢出/ 0:不溢出
	void ME_NB_SetQuality(_int index,_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);

	void ME_NB_GetQuality(_int index,_BYTE *IV,_BYTE *NT,_BYTE *SB,_BYTE *BL,_BYTE *OV);
	_BYTE ME_NB_GetByteQuality(_int index);
	bool ME_NB_ScanQualityChange();
	void ME_NB_SetToPara();
public:
	bool ME_NB_judgeDatachangeflag(_int index,TP_ME_NB *value);
	ASDU_ATTRI ME_NB_asdu_attri[Data_ME_NB_COUNTS_MAX ];
	//TP_ME_NB	ME_NB_deadband[Data_ME_NB_COUNTS];
	_int ME_NB_valveptr[Data_ME_NB_COUNTS_MAX ];
	_int ME_NB_highlimit[Data_ME_NB_COUNTS_MAX ];
	_int ME_NB_lowlimit[Data_ME_NB_COUNTS_MAX ];
	

	_int ME_NB_SpecialSpontPtr;
	_int ME_NB_SpontPtr;
	_int ME_NB_ReqcallPtr;
	_int ME_NB_CyclescanPtr;
	_int ME_NB_BackgroundPtr;
	bool ME_NB_Reqcallflag;
	bool ME_NB_Cycleflag;
	bool ME_NB_Backflag;

	TP_ME_NB	ME_NB_data_val[Data_ME_NB_COUNTS_MAX ];
	TP_ME_NB	ME_NB_data_old_val[Data_ME_NB_COUNTS_MAX ];
	_BYTE		ME_NB_data_quality[Data_ME_NB_COUNTS_MAX ];
	_BYTE		ME_NB_data_old_quality[Data_ME_NB_COUNTS_MAX ];
	bool		ME_NB_changeflag[Data_ME_NB_COUNTS_MAX ];
	bool		ME_NB_changequalflag[Data_ME_NB_COUNTS_MAX ];
	_BYTE		ME_NB_specialCOT[Data_ME_NB_COUNTS_MAX ];
//=================================================================================================

public:	

	void ME_NC_ResetDataflag();
	_int ME_NC_GetEventFrame(_BYTE* buff);//
	_int ME_NC_GetReqcallFrame(_BYTE* buff,_BYTE group);
	_int ME_NC_GetBackgroundFrame(_BYTE* buff);
	_int ME_NC_GetCycleFrame(_BYTE* buff);
	bool ME_NC_ScanEventSpontFlag();
	bool ME_NC_ScanReqcallFlag(_BYTE group);
	bool ME_NC_ScanCycleFlag();
	bool ME_NC_ScanBackFlag();
	void ME_NC_SetData(_int index, TP_ME_NC * value);
	void ME_NC_SetDeadBand(_int index,TP_ME_NC deadband);
	TP_ME_NC   ME_NC_GetDeadBand(_int index);
	TP_ME_NC	ME_NC_GetData(_int index);
	TP_ME_NC	ME_NC_viewdata(_int index);
	TP_ME_NC	ME_NC_GetOldData(_int index);
	//IV: 0有效/1无效   NT:0当前值/1非当前   SB:0未取代/1被取代  BL:0未被闭锁/1闭锁   OV:1溢出/ 0:不溢出
	void ME_NC_SetQuality(_int index,_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);

	void ME_NC_GetQuality(_int index,_BYTE *IV,_BYTE *NT,_BYTE *SB,_BYTE *BL,_BYTE *OV);
	_BYTE ME_NC_GetByteQuality(_int index);
	bool ME_NC_ScanQualityChange();
	void ME_NC_SetToPara();
public:
	bool ME_NC_judgeDatachangeflag(_int index,TP_ME_NC *value);
	ASDU_ATTRI ME_NC_asdu_attri[Data_ME_NC_COUNTS_MAX ];
	//TP_ME_NC	ME_NC_deadband[Data_ME_NC_COUNTS];
	_int ME_NC_valveptr[Data_ME_NC_COUNTS_MAX ];
	_int ME_NC_highlimit[Data_ME_NC_COUNTS_MAX ];
	_int ME_NC_lowlimit[Data_ME_NC_COUNTS_MAX ];
	

	_int ME_NC_SpecialSpontPtr;
	_int ME_NC_SpontPtr;
	_int ME_NC_ReqcallPtr;
	_int ME_NC_CyclescanPtr;
	_int ME_NC_BackgroundPtr;
	bool ME_NC_Reqcallflag;
	bool ME_NC_Cycleflag;
	bool ME_NC_Backflag;

	TP_ME_NC	ME_NC_data_val[Data_ME_NC_COUNTS_MAX ];
	TP_ME_NC	ME_NC_data_old_val[Data_ME_NC_COUNTS_MAX ];
	_BYTE		ME_NC_data_quality[Data_ME_NC_COUNTS_MAX ];
	_BYTE		ME_NC_data_old_quality[Data_ME_NC_COUNTS_MAX ];
	bool		ME_NC_changeflag[Data_ME_NC_COUNTS_MAX ];
	bool		ME_NC_changequalflag[Data_ME_NC_COUNTS_MAX ];
	_BYTE		ME_NC_specialCOT[Data_ME_NC_COUNTS_MAX ];
//=================================================================================================


	bool ME_TA_IsEmpty();
	_int ME_TA_GetCounts();
	_int ME_TA_GetdispPtr();
	bool ME_TA_AddOneRecorder();
	bool ME_TA_GetFirstRecorder();
	bool ME_TA_RemoveOneRecorder();
	
	
	void ME_TA_SetDataIndex(_WORD index);
		

	void ME_TA_SetData(TP_ME_NA *value);//Note: index-->infobodyaddr 
	void ME_TA_SetCOT(_BYTE cot);//Note: index-->infobodyaddr 
	void ME_TA_SetTimeTag(TIME_STRU *value);//Note: index-->infobodyaddr 
	void ME_TA_SetQuality(_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);
	
	void ME_TA_ResetDataflag();
	_int ME_TA_GetEventFrame(_BYTE* buff);//
	_int ME_TD_GetEventFrame(_BYTE* buff);//
	bool ME_TA_ScanEventSpontFlag();

	typedef struct ME_TA_Seqstru
	{
		_BYTE SpecialCOT;
		_WORD		index;//
		TIME_STRU	timetag;
		TP_ME_NA		data_val;
		_BYTE		data_quality;
	} 	ME_TA_SEQ_STRU;
	void ME_TA_dispStore(ME_TA_SEQ_STRU *soe);
public:
	ME_TA_SEQ_STRU ME_TA_SeqNode;
	ME_TA_SEQ_STRU ME_TA_dispBuf[Data_ME_TA_dispCOUNTS];
	_int ME_TA_dispPtr;
	ME_TA_SEQ_STRU ME_TA_seqlist[Data_ME_TA_COUNTS];
	_WORD ME_TA_counter;
//==============================================================================
	bool EP_TA_IsEmpty();
	_int EP_TA_GetCounts();
	_int EP_TA_GetdispPtr();
	bool EP_TA_AddOneRecorder();
	bool EP_TA_GetFirstRecorder();
	bool EP_TA_RemoveOneRecorder();
	void EP_TA_SetDataIndex(_WORD index);
	void EP_TA_SetData(TP_EP_TA *value);//Note: index-->infobodyaddr 
	void EP_TA_SetCOT(_BYTE cot);//Note: index-->infobodyaddr 
	void EP_TA_SetTimeTag(TIME_STRU *value);//Note: index-->infobodyaddr 
	void EP_TA_SetQuality(_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);
	void EP_TA_ResetDataflag();
	_int EP_TA_GetEventFrame(_BYTE* buff);//
	_int EP_TD_GetEventFrame(_BYTE* buff);//
	bool EP_TA_ScanEventSpontFlag();

	typedef struct EP_TA_Seqstru
	{
		_BYTE SpecialCOT;
		_WORD		index;//
		TIME_STRU	timetag;
		TP_EP_TA		data_val;
		_BYTE		data_quality;
	} 	EP_TA_SEQ_STRU;
	void EP_TA_dispStore(EP_TA_SEQ_STRU *soe);
public:
	EP_TA_SEQ_STRU EP_TA_SeqNode;
	EP_TA_SEQ_STRU EP_TA_dispBuf[Data_EP_TA_dispCOUNTS];
	_int EP_TA_dispPtr;
	EP_TA_SEQ_STRU EP_TA_seqlist[Data_EP_TA_COUNTS];
	_WORD EP_TA_counter;
//=================================================================================================
	bool EP_TB_IsEmpty();
	_int EP_TB_GetCounts();
	_int EP_TB_GetdispPtr();
	bool EP_TB_AddOneRecorder();
	bool EP_TB_GetFirstRecorder();
	bool EP_TB_RemoveOneRecorder();
	void EP_TB_SetDataIndex(_WORD index);
	void EP_TB_SetData(TP_EP_TB *value);//Note: index-->infobodyaddr 
	void EP_TB_SetCOT(_BYTE cot);//Note: index-->infobodyaddr 
	void EP_TB_SetTimeTag(TIME_STRU *value);//Note: index-->infobodyaddr 
	void EP_TB_SetQuality(_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);
	void EP_TB_ResetDataflag();
	_int EP_TB_GetEventFrame(_BYTE* buff);//
	_int EP_TE_GetEventFrame(_BYTE* buff);//
	bool EP_TB_ScanEventSpontFlag();

	typedef struct EP_TB_Seqstru
	{
		_BYTE SpecialCOT;
		_WORD		index;//
		TIME_STRU	timetag;
		TP_EP_TB		data_val;
		_BYTE		data_quality;
	} 	EP_TB_SEQ_STRU;
	void EP_TB_dispStore(EP_TB_SEQ_STRU *soe);
public:
	EP_TB_SEQ_STRU EP_TB_SeqNode;
	EP_TB_SEQ_STRU EP_TB_dispBuf[Data_EP_TB_dispCOUNTS];
	_int EP_TB_dispPtr;
	EP_TB_SEQ_STRU EP_TB_seqlist[Data_EP_TB_COUNTS];
	_WORD EP_TB_counter;
//========================================================================================
//=================================================================================================
	bool EP_TC_IsEmpty();
	_int EP_TC_GetCounts();
	_int EP_TC_GetdispPtr();
	bool EP_TC_AddOneRecorder();
	bool EP_TC_GetFirstRecorder();
	bool EP_TC_RemoveOneRecorder();
	void EP_TC_SetDataIndex(_WORD index);
	void EP_TC_SetData(TP_EP_TC *value);//Note: index-->infobodyaddr 
	void EP_TC_SetCOT(_BYTE cot);//Note: index-->infobodyaddr 
	void EP_TC_SetTimeTag(TIME_STRU *value);//Note: index-->infobodyaddr 
	void EP_TC_SetQuality(_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);
	void EP_TC_ResetDataflag();
	_int EP_TC_GetEventFrame(_BYTE* buff);//
	_int EP_TF_GetEventFrame(_BYTE* buff);//
	bool EP_TC_ScanEventSpontFlag();

	typedef struct EP_TC_Seqstru
	{
		_BYTE SpecialCOT;
		_WORD		index;//
		TIME_STRU	timetag;
		TP_EP_TC		data_val;
		_BYTE		data_quality;
	} 	EP_TC_SEQ_STRU;
	void EP_TC_dispStore(EP_TC_SEQ_STRU *soe);
public:
	EP_TC_SEQ_STRU EP_TC_SeqNode;
	EP_TC_SEQ_STRU EP_TC_dispBuf[Data_EP_TC_dispCOUNTS];
	_int EP_TC_dispPtr;
	EP_TC_SEQ_STRU EP_TC_seqlist[Data_EP_TC_COUNTS];
	_WORD EP_TC_counter;
//========================================================================================
	bool ME_TB_IsEmpty();
	_int ME_TB_GetCounts();
	_int ME_TB_GetdispPtr();
	bool ME_TB_AddOneRecorder();
	bool ME_TB_GetFirstRecorder();
	bool ME_TB_RemoveOneRecorder();
	
	
	void ME_TB_SetDataIndex(_WORD index);
		

	void ME_TB_SetData(TP_ME_NB *value);//Note: index-->infobodyaddr 
	void ME_TB_SetCOT(_BYTE cot);//Note: index-->infobodyaddr 
	void ME_TB_SetTimeTag(TIME_STRU *value);//Note: index-->infobodyaddr 
	void ME_TB_SetQuality(_BYTE IV=255,_BYTE NT=255,_BYTE SB=255,_BYTE BL=255,_BYTE OV=255);
	
	void ME_TB_ResetDataflag();
	_int ME_TB_GetEventFrame(_BYTE* buff);//
	_int ME_TE_GetEventFrame(_BYTE* buff);//
	bool ME_TB_ScanEventSpontFlag();

	typedef struct ME_TB_Seqstru
	{
		_BYTE SpecialCOT;
		_WORD		index;//
		TIME_STRU	timetag;
		TP_ME_NB		data_val;
		_BYTE		data_quality;
	} 	ME_TB_SEQ_STRU;
	void ME_TB_dispStore(ME_TB_SEQ_STRU *soe);
public:
	ME_TB_SEQ_STRU ME_TB_SeqNode;
	ME_TB_SEQ_STRU ME_TB_dispBuf[Data_ME_TB_dispCOUNTS];
	_int ME_TB_dispPtr;
	ME_TB_SEQ_STRU ME_TB_seqlist[Data_ME_TB_COUNTS];
	_WORD ME_TB_counter;
//==============================================================================
//=================================================================================================


	bool ME_TC_IsEmpty();
	_int ME_TC_GetCounts();
	_int ME_TC_GetdispPtr();
	bool ME_TC_AddOneRecorder();
	bool ME_TC_GetFirstRecorder();
	bool ME_TC_RemoveOneRecorder();