/**********************************************************************************************
*   モジュール名称      ：APP03 Mission TLM (L&M) PI tasks                                    *
*   モジュールラベル    ：app03_PIs                                                           *
*   タスク区分          ：Application-03  MGF task for Mission TLM (L&M)                      *
*   機能                ：                                                                    *
*   コーリングシーケンス：void app03_(PI)                                                     *
*   引数                ：なし                                                                *
*   戻り値              ：なし                                                                *
*   使用上の注意        ：グローバル変数はアプリケーション０１でまとめて初期化                *
*   エラー処理          ：なし                                                                *
*   注意				：  EDIT権限は、MGF組                                                 *
*   作成日・作成者      ：2011/07/26    rev by Y.K.                                           *
*   改定日・改定者      ：2011/09/02    A. Matsuoka サイズ縮小                                *
*   改定日・改定者      ：2011/09/15    put_TLM TI 修正                                       *
*   改定日・改定者      ：2011/10/06    uninitialized warning 除去                            *
*   改定日・改定者      ：2011/10/11    rev by Y.K.                                           *
*   改定日・改定者      ：2011/11/15    rev by Y.K. (CMP-mode)                                *
*   改定日・改定者      ：2012/06/07    A. Matsuoka 全面改定                                  *
*   改定日・改定者      ：2012/11/25    rev by Y.L. (TRG data部)                              *
*   改定日・改定者      ：2013/03/22    A. Matsuoka checkout TI 4bit shift                    *
*   改定日・改定者      ：2013/03/25    A. Matsuoka correction of TI of the last data of spin *
*   改定日・改定者      ：2013/04/05    A. Matsuoka correction of TI of the last data of spin *
*   改定日・改定者      ：2013/11/08    A. Matsuoka                                           *
*                               1. format of M and L node data (multiple spins in one packet) *
*                               2. SW parameter set command length                            *
*                               3. correction of overflow judgement in app03_MGF_spin_fit     *
*   改定日・改定者      ：2013/11/19    A. Matsuoka                                           *
*   改定日・改定者      ：2017/03/25    A. Matsuoka                                           *
*                               correct the error causing the M-mode data lack                *
*                               in the specific condition when IP occurs between the exact    *
*                               integer seconds of TI and the first MGF sample after that.    *
***********************************************************************************************/

#include "app_common.h"							// **** revised by YK	111008 ****
// #include "app_common_math.h"					// **** revised by YK	111008 ****
#include "app_MGF.h"

#define 		MATH_PI        (3.1415926536)

void app_MGF_common( unsigned char, unsigned int ) ;

/* 以下は APP03, APP13 に属する
void app03_MGF( unsigned char, unsigned int ) ;

void	app03_MGFO( unsigned int ui_sunpulseCnt )
{
	app_MGF_common(0, ui_sunpulseCnt ) ;
	return;
}

void	app13_MGFI( unsigned int ui_sunpulseCnt )
{ 
	app_MGF_common(1, ui_sunpulseCnt ) ;
	return;
}
*/


/* Command check */
void app03_MGF_cmd_check( unsigned char) ;

/* SpW mission read */
int app03_MGF_mss_read( unsigned char) ;

/* conversion of SpW raw data into physical values */
void app03_MGF_mss_full_store(unsigned char) ;

/* processing of data */
void app03_MGF_mss_process( unsigned char) ;

/* functions for processing in app03_MGF_mss_process */
void app03_MGF_average(unsigned char, unsigned short) ;
void app03_MGF_def_shift(unsigned char, unsigned short) ;
void app03_MGF_spin_fit(unsigned char, unsigned short) ;
void app03_MGF_TLM_header(unsigned char, unsigned short) ;
void app03_MGF_every_1s_process(unsigned char, unsigned short) ;

/* mission data out */
void app03_MGF_put_TLM_hmode(unsigned char, int, unsigned long) ;  // add unsigned long 110914
void app03_MGF_put_TLM_HML(unsigned char, unsigned short) ;  // add unsigned short 110914


// ###########################################################################
// app03_MGF	*** MGF メインルーチン（MGF-O/I 共通） ***
//		[INPUT]		unsigned char	uc_mgfoi				0:MGF-O 1:MGF-I
//		[INPUT]		unsigned char	ui_sunpulseCnt			Sun-pulse counter
//		[return]	void
// ###########################################################################

void app_MGF_common( unsigned char uc_mgfoi, unsigned int ui_sunpulseCnt )
{
	int i, i_mss_read ;
	
	app03_MGF_cmd_check(uc_mgfoi) ;
	
	for(i=0;i<2;i++) {  // add 20131119
		i_mss_read = app03_MGF_mss_read(uc_mgfoi) ;  // add 20131119
	// if(0 < app03_MGF_mss_read(uc_mgfoi)) {  // delete 20131119
		if(0 < i_mss_read) {
			// new mission data exist
			app03_MGF_mss_full_store(uc_mgfoi) ;
			app03_MGF_mss_process(uc_mgfoi) ;
		}
		if(i_mss_read < 5) break ;  // add 20131119
	}  // match with for(i=0;i<2;i++)
	return ;
}


void app03_MGF_cmd_check(unsigned char uc_mgfoi)
{
	unsigned char uc1 ;
	unsigned char uc_kind ;  // add 20131108 Matsuoka
	int i,i2, m ;
	union uni_long {
		short s[2] ;
		unsigned char uc[4] ;
		long l ;
	} u_long ;
	unsigned char *puc, *puc1, *puc2, *puc10, *puc20 ;
	long *pl ;
	short *ps ;
	
	// initialize of software HK
	puc = Guc_MGF_HK[uc_mgfoi] ;  // pointer of Guc_MGF_HK[uc_mgfoi][0]
	for(i=0;i<20;i++) *(puc++) = 0 ;
	
	// TLM Parameters
	puc = Guc_MGF_TLM_Param[uc_mgfoi] ; // pointer for Guc_MGF_TLM_Param[uc_mgfoi][0]
	puc1 = (puc10 = Guc_MGF_TLM_out[uc_mgfoi])  ;  // pointer for Guc_MGF_TLM_out[uc_mgfoi][0]
	puc2 = (puc20 = Guc_MGF_TLM_rate[uc_mgfoi]) ;  // pointer for Guc_MGF_TLM_rate[uc_mgfoi][0]
	if(*puc>0) {  //  new command exist
		*puc = 0 ;  // reset command code
		puc+=2 ;  //  proceed to D2 'L-mode out'
		for(i=0;i<3;i++) {  // L, M, H mode loop
			uc1 =*(puc++) ; // TLM out
			if(0x0f!=uc1) *puc1 = uc1 ;  // replace of out
			puc1++ ;
			uc1 =*(puc++) ; // TLM rate
			if(0x0f!=uc1) *puc2 = uc1 ;  // replace of rate
			puc2++ ;
		}
	}

	// TLM out and rate are stored in HK
	puc = Guc_MGF_HK[uc_mgfoi] + 12 ; // pointer for Guc_MGF_HK[uc_mgfoi][12]
	puc1 = puc10 ;  // pointer for Guc_MGF_TLM_out[uc_mgfoi][0]
	puc2 = puc20 ;  // pointer for Guc_MGF_TLM_rate[uc_mgfoi][0]
	for(i=0;i<3;i++) *(puc++) = ((*(puc1++))<<4) + (*(puc2++)) ;
	
	// Software Parameters
	for(i=0;i<Gl_MGF_SwP_n[uc_mgfoi];i++) {  // when new command execution occurs, 0 < Gl_MGF_SwP_n[uc_mgfoi]
		puc = Guc_MGF_Sw_Param[uc_mgfoi][i] ;  // pointer of Guc_MGF_Sw_Param[uc_mgfoi][i][0]
		uc1 = *(puc++) ;  // Guc_MGF_Sw_Param[uc_mgfoi][i][0] : command code of i-th command
		uc_kind = uc1 & 0xF0 ;  // upper 4 bits = command kind, add 20131108 Matsuoka
		
		// what kind of command ?
		if(0x10==uc_kind) {  // gain and angle for conversion, add 20131108 Matsuoka
		// if(1==uc1) {  // delete 20131108 Matsuoka
			// m = *(puc++) ;  // delete 20131108 Matsuoka
			m = uc1 & 0x03 ;  // lower 4bits of Guc_MGF_Sw_Param[uc_mgfoi][i][0] = axis id, 0=x, 1=y, 2=z
			// if(m<0 || m>2) break ;  // invalid axis, break from for loop
			#ifdef TLM_STAT
			memcpy(&Guc_MGF_TLM_stat[uc_mgfoi][14 + m*18], puc, 18) ;  // copy to TLM_stat
			#endif
			ps = Gs_MGF_cnv[uc_mgfoi][m][0] ;  // pointer of Gs_MGF_cnv[uc_mgfoi][m][0][0]
			for(i2=0;i2<9;i2++) {
				u_long.uc[0] = *(puc++) ;
				u_long.uc[1] = *(puc++) ;
				*(ps++) = u_long.s[0] ;
			}
		}  // match with if(1==uc1)

		if(0x20==uc_kind) {  // offset for conversion, add 20131108 Matsuoka
		// if(2==uc1) {  // delete 20131108 Matsuoka
			// puc++ ;  // delete 20131108 Matsuoka
			#ifdef TLM_STAT
			memcpy(&Guc_MGF_TLM_stat[uc_mgfoi][68], puc, 6) ;  // copy to TLM_stat
			#endif
			ps = Gs_MGF_off[uc_mgfoi] ; // pointer for Gs_MGF_off[uc_mgfoi][0]
			for(i2=0;i2<3;i2++) {
				u_long.uc[0] = *(puc++) ;
				u_long.uc[1] = *(puc++) ;
				*(ps++) = (long) u_long.s[0] ;
			}
		}  // match with if(2==uc1)

		if(0x30==uc_kind) {  // bit shift and major values, add 20131108 Matsuoka
		// if(3==uc1) {  // delete 20131108 Matsuoka
			// puc++ ;  // delete 20131108 Matsuoka

			// Here puc = pointer of Guc_MGF_Sw_Param[uc_mgfoi][i][1], shift flag of x-axis
			puc2 = puc + 1 ;  // pointer of Guc_MGF_Sw_Param[uc_mgfoi][i][2] , major flag of x-axis
			
			// copy of shift flag
			puc1 = Guc_MGF_shift_flag[uc_mgfoi] ;  // pointer of Guc_MGF_shift_flag[uc_mgfoi][0]
			for(i2=0;i2<2;i2++) {
				if(0x0f != (*puc)) *puc1 = *puc ;
				puc1++ ;
				puc += 4 ;
			}
			
			// copy of major flag
			puc1 = Guc_MGF_mjr_flag[uc_mgfoi] ;  // pointer of Guc_MGF_mjr_flag[uc_mgfoi][0]
			for(i2=0;i2<2;i2++) {
				if(0x0f != (*puc2)) *puc1 = *puc2 ;
				puc1++ ;
				puc2 += 4 ;
			}
			
			// copy of major values
			puc = Guc_MGF_Sw_Param[uc_mgfoi][i] + 3 ;
			//  pointer of Guc_MGF_Sw_Param[uc_mgfoi][i][3], 4->3 change 20131108 Matsuoka
			pl = Gl_MGF_sub[uc_mgfoi] ; // pointer to Gl_MGF_sub[uc_mgfoi][0]
			for(i2=0;i2<3;i2++) {  // Guc_MGF_Sw_Param[uc_mgfoi][i][4, 5, 8, 9, 12, 13]
				u_long.uc[0] = *(puc++) ;
				u_long.uc[1] = *(puc++) ;
				*(pl++) = ((long) u_long.s[0]) << 8 ; // b8=62.5pT for Gl_MGF_sub
				puc += 2 ;
			}
		}  // match with if(3==uc1)
		
		Guc_MGF_Sw_Param[uc_mgfoi][i][0] = 0 ; // reset command code
		
	}  // match with for(i=0;i<Gl_MGF_SwP_n[uc_mgfoi];i++)
	
	Gl_MGF_SwP_n[uc_mgfoi] = 0 ;  // reset command counter
		
	return ;
}


// ###########################################################################
// app03_MGF_mss_read	*** MGF mission data read ***
//		[INPUT]		unsigned char	uc_mgfoi				0:MGF-O 1:MGF-I
//		[return]	int
// ###########################################################################

int app03_MGF_mss_read( unsigned char uc_mgfoi)
{

// typedef struct M_T_BLOCK_INFO	{
//     unsigned int                           ui_createTime;   // ＢＬＯＣＫ生成時刻		LSB=31.25ms
//     int                                    i_replyNum;      // リプライ数
//     char                                   c_invalidFlg;    // 異常フラグ
//     unsigned int                           ui_blockIndex;   // ＢＬＯＣＫインデックス
// } M_T_BLOCK_INFO;

	int i_bufId, i_numNewBlock, i_sizeData ;
	M_T_BLOCK_INFO 	tp_blockInfo ;
	int				i, i2, i_flag, i3, ip ; 				// ****** COMMENT OUT by YK 	110725 ******
	// unsigned char uc ;									// ****** COMMENT OUT by YK 	110725 ******
	union uni_long {
		long l ;
		unsigned long ul ;
		short s[2] ;
		unsigned short us[2] ;
		unsigned char uc[4] ;
	} u_long ;
	unsigned char *puc, *puc2 ;
	// short *ps ;
	
	unsigned long ul_start_ti ;
	
	puc = NULL ;  // initialize to avoid the warning

// -----------------------------------------------------------
// -- Set at the buffer with the oldest non-processed block --
// -----------------------------------------------------------
// extern int app_CheckNonProcBlock	
//              ( unsigned char, unsigned char, unsigned int, unsigned int *);
// ===========================================================================
// app_CheckNonProcBlock	***	"ui_TLM_blockTime" 直後のＴＩを持ったBlockを有
//                               するバッファを探す (Long or Short or Nothing)
//		[INPUT]			unsigned char	uc_nodeId				Node-ID
//						unsigned char	uc_dataId				Data-ID
//						unsigned int	ui_TLM_blockTime		処理済データ(等)のTI
//		[OUTPUT]		unsigned int	*uip_TLM_blockTimeNew	当該バッファ最新ブロックのTI
//		[return]		int				選ばれたBuffer-ID (0:L, 1:S, -1:no data)
// ===========================================================================

	i_bufId = app_CheckNonProcBlock( Guc_node_mgf[uc_mgfoi], 0, 					// [INPUT]  Node/Data ID			// ***** CHANGED!  110721 YK
									//    Gui_MGF_TLM_lastblock_TI[uc_mgfoi],		// [INPUT]  TI of Processed Block	// ***** CHANGED!  111011 YK
										  Gui_TLMm_blockTime[ Gd_N_MGFO + uc_mgfoi ], 									// ***** CHANGED!  111011 YK
										  &Gui_MGF_TLM_block_TI[uc_mgfoi]);			// [OUTPUT] TI of Newest Block in the selected buffer
																					// (return) Buffer-ID  (0:L, 1:S, -1:no data)

	// copy Gui_TLMm_blockTime to HK and TLM_stat
	u_long.ul = Gui_TLMm_blockTime[ Gd_N_MGFO + uc_mgfoi ] ;
	// puc1 = Guc_MGF_HK[uc_mgfoi] + 15;  // pointer of Guc_MGF_HK[uc_mgfoi][15]
	// puc3 = Guc_MGF_TLM_stat[uc_mgfoi] + 74 ;  // pointer for Guc_MGF_TLM_stat[uc_mgfoi][74]
	// puc2 = u_long.uc ;
	// for(i=0;i<4;i++) *(puc1++) = (*(pc3++) = *(puc2++)) ;  // copy to HK and TLM_stat
	memcpy( &Guc_MGF_HK[uc_mgfoi][15],       u_long.uc, 4) ;
	#ifdef TLM_STAT
	memcpy( &Guc_MGF_TLM_stat[uc_mgfoi][74], u_long.uc, 4) ;
	#endif
	
	if ( i_bufId < 0 ) {  // no data
		return -1;
	}
	
	// copy Gui_MGF_TLM_block_TI TLM_stat
	// now pc3 is pointer of Guc_MGF_TLM_stat[uc_mgfoi][80]
	u_long.ul = (ul_start_ti = Gui_MGF_TLM_block_TI[uc_mgfoi]) ;
	// puc2 = u_long.uc ;
	// for(i=0;i<4;i++) *(pc3++) = *(puc2++) ;  // copy TLM_stat
	#ifdef TLM_STAT
	memcpy( &Guc_MGF_TLM_stat[uc_mgfoi][78], u_long.uc, 4) ;
	#endif

// -------------------------------------------
// -- Set at the oldest non-processed block --
// -------------------------------------------
// Newest Block
// extern int app_SetNonProcBlock
//       ( unsigned char, unsigned char, int, unsigned int, M_T_BLOCK_INFO *);
// ===========================================================================
// app_SetNonProcBlock	***FUNC***	"ui_TLM_blockTime" 直後のＴＩを持ったBlock
//                                                              をみつける ***
//		[INPUT]			unsigned char	uc_nodeId				Node-ID
//						unsigned char	uc_dataId				Data-ID
//						int				i_bufId					Buffer-ID
//						unsigned int	ui_TLM_blockTime		処理済データ(等)のTI
//		[OUTPUT]		M_T_BLOCK_INFO 	*tp_blockInfo			Block Info
//		[return]		int				>0:Num of blocks, <=0:error
// ===========================================================================
	i_numNewBlock	= app_SetNonProcBlock( Guc_node_mgf[uc_mgfoi], 0, 			// [INPUT]  Node/Data ID						// ***** CHANGED!  110721 YK
										   i_bufId,  							// [INPUT]  Buffer ID
									//     Gui_MGF_TLM_lastblock_TI[uc_mgfoi],	// [INPUT]  TI of Processed Block				// ***** CHANGED!  111011 YK
										   Gui_TLMm_blockTime[ Gd_N_MGFO + uc_mgfoi ], 											// ***** CHANGED!  111011 YK
										   &tp_blockInfo);						// [OUTPUT] Block Info
																				// (return)	>0:Num of blocks, <=0:No data (error)
	// copy i_numNewBlock lowest byte to HK
	u_long.l = i_numNewBlock ;
	Guc_MGF_HK[uc_mgfoi][19] = u_long.uc[3] ;  // copy to HK
	
	if ( i_numNewBlock < 1 ) {  // no data or error
		return i_numNewBlock ;
	}
	
	#ifdef TLM_STAT
	// copy i_numNewBlock to TLM_stat
	// now pc3 is pointer of Guc_MGF_TLM_stat[uc_mgfoi][82]
	// puc2 = u_long.uc ;  // pointer of u_long.uc[0]
	// for(i=0;i<4;i++) *(puc3++) = *(puc2++) ;  // copy to Guc_MGF_TLM_stat
	memcpy(&Guc_MGF_TLM_stat[uc_mgfoi][82], u_long.uc, 4) ;
	#endif

	// if(i_numNewBlock > 6) i_numNewBlock = 6 ;  // delete 20131119
	if(i_numNewBlock > 5) i_numNewBlock = 5 ;  // add 20131119
	
	#ifdef TLM_STAT
	// TLM_stat output
	if((1==Guc_MGF_TLM_out[uc_mgfoi][2]) && (0x0c==(0x0c&Guc_MGF_TLM_rate[uc_mgfoi][2]))) {  // rate = c or larger
		Guc_MGF_TLM_stat[uc_mgfoi][0]  = (uc_mgfoi<<4) + 0x0d ;
		// puc1 = Guc_MGF_hmode[uc_mgfoi] ;  // pointer for Guc_MGF_hmode[uc_mgfoi][0]
		// puc2 = Guc_MGF_TLM_stat[uc_mgfoi] ; // pointer for Guc_MGF_TLM_stat[uc_mgfoi][0]
		// for (i=0; i<Gl_MGF_TLM_stat_len; i++) *(puc1++) = *(puc2++) ;  // copy from TLM_stat to hmode
		memcpy(Guc_MGF_hmode[uc_mgfoi], Guc_MGF_TLM_stat[uc_mgfoi], Gl_MGF_TLM_stat_len) ;
		app03_MGF_put_TLM_hmode(uc_mgfoi,Gl_MGF_TLM_stat_len, ul_start_ti) ;   // TLM_stat putTLM
	}
	#endif

	// ---------------------
	// -- Read Block data --
	// ---------------------
	for (i=0; i<i_numNewBlock; i++) {  // block loop
		if ( // tp_blockInfo.ui_createTime > Gui_MGF_TLM_lastblock_TI[uc_mgfoi]	&&		// NEW data					// ***** CHANGED!  111011 YK
				tp_blockInfo.ui_createTime > Gui_TLMm_blockTime[ Gd_N_MGFO + uc_mgfoi ] &&							// ***** CHANGED!  111011 YK
			 tp_blockInfo.i_replyNum    > 0					&&							// Data available
			 tp_blockInfo.c_invalidFlg == 0 ) {											// Data correct

// **** Block read ****
// extern	int		app_GetBlock			( unsigned char, unsigned char, int, M_T_BLOCK_INFO *,                unsigned char []);
// ===========================================================================
// app_GetBlock		***	Block DataのSRAM展開 ***
//		[INPUT]		unsigned char	uc_nodeId				Node-ID
//					unsigned char	uc_dataId				Data-ID
//					int				i_bufId					Buffer-ID
//					M_T_BLOCK_INFO 	*tp_blockInfo			Block Info
//		[OUTPUT]	unsigned char	uc_data[]				Block data
//		[return]	int				0:nrm  others:error
// ===========================================================================

			if (uc_mgfoi == 0)	{
				// *********MGFO**********************************************
				i_flag = app_GetBlock( 	3,											// [INPUT]  App-No:3
										Guc_node_mgf[uc_mgfoi], 0,					// [INPUT]  Node/Data ID						// ***** CHANGED!  110721 YK
										i_bufId,  									// [INPUT]  Buffer ID
										&tp_blockInfo,								// [INPUT]  Block Info
										G03uc_data );								// [OUTPUT] 1 Block Data - copied
			} else {
				// *********MGFI***********************************************
				i_flag = app_GetBlock( 	13,											// [INPUT]  App-No:13
										Guc_node_mgf[uc_mgfoi], 0,					// [INPUT]  Node/Data ID							// ***** CHANGED!  110721 YK
										i_bufId,  									// [INPUT]  Buffer ID
										&tp_blockInfo,								// [INPUT]  Block Info
										G13uc_data );								// [OUTPUT] 1 Block Data - copied
			}
			
			if(0==i_flag) {  // normal read
				for(i2=0;i2<Gus_MGF_packet_def_n_in_block;i2++) {
				// data copy to Guc_MGF_raw and Guc_MGF_hmode(Checkout)
				// packet loop ; Gus_MGF_packet_def_n_in_block = 9
					ip = i2*Gl_MGF_mss_packet_len + 12 ; 
					// start position of data body in G03uc_data; Gl_MGF_mss_packet_len = 224
					// if(uc_mgfoi == 0) puc = G03uc_data + ip ;  // pointer for G03uc_data[ip], MGF-O
					// if(uc_mgfoi == 1) puc = G13uc_data + ip ;  // pointer for G13uc_data[ip], MGF-I
					// puc1 = Guc_MGF_raw[uc_mgfoi][i][i2] ; // pointer for Guc_MGF_raw[uc_mgfoi][i][i2][0]
					// reminder : 'i' is block counter
					// pointer for Guc_MGF_hmode[uc_mgfoi][(i2%3)*Gl_MGF_dat_packet_len+Gus_MGF_TLM_CO_header_length]
					// puc2 = Guc_MGF_hmode[uc_mgfoi] + (i2%3)*Gl_MGF_dat_packet_len + Gus_MGF_TLM_CO_header_length ;
					// for(i3=0;i3<Gl_MGF_dat_packet_len;i3++) {  // data byte loop, Gl_MGF_dat_packet_len = 202
					//	*(puc1++) = *puc ;  // copy to Guc_MGF_raw
					//	*(puc2++) = *(puc++) ;  // copy to Guc_MGF_hmode
					// }  // match with for(i3=0;
					if(uc_mgfoi == 0) memcpy(Guc_MGF_raw[0][i][i2], &G03uc_data[ip], Gl_MGF_dat_packet_len) ;
					if(uc_mgfoi == 1) memcpy(Guc_MGF_raw[1][i][i2], &G13uc_data[ip], Gl_MGF_dat_packet_len) ;
					i3 = (i2%3)*Gl_MGF_dat_packet_len+Gus_MGF_TLM_CO_header_length ;
					memcpy(&Guc_MGF_hmode[uc_mgfoi][i3], Guc_MGF_raw[uc_mgfoi][i][i2], Gl_MGF_dat_packet_len) ;
					
					if((2==i2%3) && (1==Guc_MGF_TLM_out[uc_mgfoi][2]) && (0x0c==Guc_MGF_TLM_rate[uc_mgfoi][2])) {
					// Checkout TLM output; i2 is packet counter, once every 3 packets
						puc2 = Guc_MGF_hmode[uc_mgfoi] ; // pointer for Guc_MGF_hmode[uc_mgfoi][0]
						*(puc2++) = (uc_mgfoi<<4) + 0x0c ;  // Guc_MGF_hmode[uc_mgfoi][0]
						u_long.l = i2/3 ;  // changed 20110725
						*(puc2++) = u_long.uc[3] ;  // Guc_MGF_hmode[uc_mgfoi][1], data counter
						puc2++ ;  // skip Guc_MGF_hmode[uc_mgfoi][2]
						u_long.us[0] = Gus_MGF_buff_in_store[uc_mgfoi] ;
						// copy lower byte of Gus_MGF_buff_in_store[uc_mgfoi] to Guc_MGF_hmode[uc_mgfoi][3]
						*(puc2++) = u_long.uc[1] ;
						for(i3=0;i3<3;i3++) {  // loop of three buffers
							// copy lower byte of Gus_MGF_buff_in_store[uc_mgfoi][0-2] to Guc_MGF_hmode[uc_mgfoi][4-6]
							u_long.us[0] = Gus_MGF_buff_stat[uc_mgfoi][i3] ;
							*puc2 = u_long.uc[1] ;
							// copy Gus_MGF_buff_n[uc_mgfoi][0-2] to Guc_MGF_hmode[uc_mgfoi][7-12]
							u_long.us[0] = Gus_MGF_buff_n[uc_mgfoi][i3] ;
							*(puc2+3+i3) = u_long.uc[0] ;
							*(puc2+4+i3) = u_long.uc[1] ;
							// copy 2nd lowest byte of Gul_MGF_buff_ti[uc_mgfoi][0-2] to Guc_MGF_hmode[uc_mgfoi][13-15]
							u_long.ul = Gul_MGF_buff_ti[uc_mgfoi][i3] ;
							*(puc2+9) = u_long.uc[2] ;
							puc2++ ;
						}
						// puc2 += 9 ;  // pointer of Guc_MGF_hmode[uc_mgfoi][16]
						u_long.ul = Gul_MGF_spin_prd[uc_mgfoi] ;  // added 20110902
						// for(i3=0;i3<2;i3++) *(puc2++) = u_long.uc[i3+2] ;  // Guc_MGF_hmode[uc_mgfoi][16-17] added 20110902
						memcpy(&Guc_MGF_hmode[uc_mgfoi][16], &u_long.uc[2], 2) ;
						i_sizeData = Gl_MGF_dat_packet_len*3+Gus_MGF_TLM_CO_header_length ;
						app03_MGF_put_TLM_hmode(uc_mgfoi,i_sizeData, ul_start_ti) ;  // Checkout putTLM  // changed 20110902
					}  // match with if((2==i2%3) &&
				}  // match with for(i2=0;
				
				// copy of TI
				// Gui_MGF_TLM_lastblock_TI[uc_mgfoi] = tp_blockInfo.ui_createTime;  // TI of the block [LSB:31.25ms] 	(MDPでの受信時刻)
				//	u_long.ul = Gui_MGF_TLM_lastblock_TI[uc_mgfoi] = tp_blockInfo.ui_createTime;  // TI of the block [LSB:31.25ms] 	(MDPでの受信時刻)   **** rev by YK 111011 ****
				Gui_TLMm_blockTime[ Gd_N_MGFO + uc_mgfoi ] = tp_blockInfo.ui_createTime;  // TI of the block [LSB:31.25ms] 	(MDPでの受信時刻)   **** rev by YK 111011 ****

			}  // match with if(0==i_flag)
		}  // match with if ( tp_blockInfo.ui_createTime

// extern	int		app_NextBlock			( unsigned char, unsigned char, int, M_T_BLOCK_INFO *);

// ===========================================================================
// app_NextBlock	*** 次の Block へ移動 ***
//		[INPUT]		unsigned char	uc_nodeId				Node-ID
//					unsigned char	uc_dataId				Data-ID
//					int				i_bufId					Buffer-ID
//		[OUTPUT]	M_T_BLOCK_INFO 	*tp_blockInfo			Block Info
//		[return]	int				0:nrm  others:error
// ===========================================================================

		i_flag = app_NextBlock( Guc_node_mgf[uc_mgfoi], 0, 							// [INPUT]  Node/Data ID // ***** CHANGED!  110721 YK
											i_bufId,  								// [INPUT]  Buffer ID
											&tp_blockInfo);							// [OUTPUT] Block Info
		if(0!=i_flag) {
			i++ ;
			break;	// escape from the for loop when no data
		}
	}
	
	Gl_MGF_mss_block[uc_mgfoi] = (u_long.l = i) ;
	Guc_MGF_HK[uc_mgfoi][0] = u_long.uc[3] ;
	
	return i ;  // changed 20110723
}


// ###########################################################################
// app03_MGF_put_TLM_hmode	*** MGF CHECKOUT mission data output to tlm ***
//		[INPUT]		unsigned char	uc_mgfoi				0:MGF-O 1:MGF-I
//		[INPUT]		int				i_sizeData				Data length
//		[INPUT]		unsigned long	ul_start_ti				TI of start data
//		[return]	void
// ###########################################################################

void app03_MGF_put_TLM_hmode(unsigned char uc_mgfoi, int i_sizeData, unsigned long ul_start_ti)  // add ul_start_ti 110914
{
	int i_flag ;
	unsigned int ui_dataTi ;
	unsigned char uc_pacId = 0 ;
	
	// if((0==Guc_MGF_TLM_out[uc_mgfoi][2]) || (0x0c!=(0x0c&Guc_MGF_TLM_rate[uc_mgfoi][2]))) {
	// 	return ;
	// }

// extern	int		app_PutTlm			( 	unsigned char,    unsigned char, unsigned char,    unsigned char, unsigned char, unsigned char, unsigned int, 
// ===========================================================================
// app_PutTlm		---- Non-Compressed / JPEG-REV / Pre-compressed telemetry ----
//		****************************************************************
//		***FUNC***	Non-Compressed / JPEG-REV / Pre-compressed telemetry
//		****************************************************************
//		[INPUT]		unsigned char	uc_nodeId				Node-ID
//					unsigned char	uc_dataId				Data-ID
//					unsigned char 	uc_headId 				Header-ID (for PID-ID, CAT-ID setting)
//					unsigned char 	uc_drId					DR-ID     (for CAT-ID) [0:HK  1:OS 2:L 3:M 4-9:H(0-5)]
//					unsigned char 	uc_cmp 					Comp mode			   [0:non 1:JPEG-rev 2:JPEG-nonrev 3:After-User-COMP]
//					unsigned char 	uc_pacId 				Packet ID 			<<<< USER-DEF:       0x00-      0xFF >>>> 
//					unsigned int  	ui_time 				Data TI				<<<< USER-DEF: 0x00000000-0xFFFFFFFF >>>>
//					unsigned char 	uc_comment[], 			Comment				<<<< USER-DEF: <128B                 >>>> 
//					unsigned char 	uc_sizeComment	 		Comment - Size 		<<<< USER-DEF: <128B                 >>>>
//					unsigned char 	uc_data[] 				Data				<<<< USER-DEF: <0x1E00               >>>> 
//					int           	i_sizeData 				Data - Size			<<<< USER-DEF: <0x1E00               >>>>
//		[return]	int				0:nrm  others:error
// ===========================================================================

	ui_dataTi = ul_start_ti << 4 ; // 20130322 4 bit shift by A.Matsuoka

	i_flag = app_PutTlm(
						Gus_MGF_app_m[uc_mgfoi],			// [INPUT]  APP-NUM = 3 (MGF-O) = 13 (MGF-I)
						Guc_node_mgf[uc_mgfoi], 			// [INPUT]	Node-ID
						0,									// [INPUT]	Data-ID											// ***** CHANGED!  110721 YK
						Guc_node_mgf[uc_mgfoi],				// [INPUT]	Header-ID (for PID-ID, CAT-ID setting)
						4,									// [INPUT]	DR-ID     (for CAT-ID) [0:HK 1:OS 2:L 3:M 4-9:H(0-5)]
						Guc_TLMh_cmp[Guc_node_mgf[uc_mgfoi]], // [INPUT]	Comp mode									// ***** CHANGED!  111115 YK
//						0, // [INPUT]	Comp mode																		// ***** CHANGED!  111115 YK
						uc_pacId, 							// [INPUT]	Packet ID 			<<<< USER-DEF:       0x00-      0xFF >>>>
						ui_dataTi, 							// [INPUT]	Data TI				<<<< USER-DEF: 0x00000000-0xFFFFFFFF >>>>
						Guc_cmdDummy, 						// [INPUT]	Comment				***** CHANGED by YK 110723 ******
						0, 									// [INPUT]	Comment - Size 		***** CHANGED by YK 110723 ******
						Guc_MGF_hmode[uc_mgfoi], 			// [INPUT]	Data				<<<< USER-DEF: <0x1E00               >>>>
						i_sizeData); 						// [INPUT]	Data - Size			<<<< USER-DEF: <0x1E00               >>>>

	return ;
}


// ###########################################################################
// app03_MGF_put_TLM_HML	*** MGF M- and L-mode mission data output to tlm ***
//		[INPUT]		unsigned char	uc_mgfoi				0:MGF-O 1:MGF-I
//		[INPUT]		unsigned short	us_buff					buffer number
//		[return]	void
// ###########################################################################

void app03_MGF_put_TLM_HML(unsigned char uc_mgfoi, unsigned short us_buff)
{
    int i, i2, id_hd[3] = {2, 3, 4}, i_sizeData, i_flag=0 ;
    int i_m_mode_l ;  // add 20131108 Matsuoka
    int i_spin[9] = {0, 8, 0, 0, 8, 0, 0, 0, 4} ;
    int i_max_n[9] = {0, 360, 0, 0, 1320, 0, 0, 0, 1180} ;
    // number of spins in data packet. i_spin[1]=8, i_spin[4]=8, i_spin[8]=4, add 20131108 Matsuoka
	unsigned char uc_sizeComment = 0, uc_pacId = 0, uc_comment[128], uc_TLM_rate, uc_TLM_out ;
	// uco[360], uc_ti_b2 deleted 20131108 Matsuoka
	// unsigned int ui_dataTi=0 ;  // delete 20131108 Matsuoka
	unsigned char *puc ;
	unsigned char *puc_tlm, *puc_tlm_first ;  // add 20131108 Matsuoka
	unsigned short us_1s_TLM_length=0, us_TLM_test_length=0 ;  // us_MGF_TLM_ML_header_length delete 20131108 Matsuoka
	// unsigned long ul_ml_start_ti ;  // delete 20131108 Matsuoka
	
	union uni_long {
		unsigned long ul ;
		unsigned short us[2] ;
		unsigned char uc[4] ;
	} u_long ;
	
	// us_MGF_TLM_ML_header_length = Gus_MGF_TLM_ML_header_length ; // delete 20131108 Matsuoka
	if(Guc_MGF_1s_n[uc_mgfoi]<1) return ;  // no data for TLM output
	// ul_ml_start_ti = (u_long.ul = Gul_MGF_ML_start_ti[uc_mgfoi] + 8) ;  // delete 20131108 Matsuoka
	// uc_ti_b2 = u_long.uc[2] ;  // delete 20131108 Matsuoka

	for(i=0;i<2;i++) {  // mode loop, 0=L, 1=M, 3->2 change 20131108 Matsuoka
		uc_TLM_out = Guc_MGF_TLM_out[uc_mgfoi][i] ;  // TLM out, =0 : non, =1 : normal out, =2 : test pattern
		uc_TLM_rate = Guc_MGF_TLM_rate[uc_mgfoi][i] ;  // TLM rate
		if(0<uc_TLM_out) {  // output ?
			if((8==uc_TLM_rate) || (4==uc_TLM_rate) || (1==uc_TLM_rate)) {  // 8Hz, 4Hz, spin
				i_sizeData = Gi_MGF_TLM_data_n[uc_mgfoi][i] ;
				// ^already stored TLM data length, add 20131108 Matsuoka
				if(0==i) {
					puc_tlm_first = Guc_MGF_TLM_Lmode[uc_mgfoi] ;
				// ^pointer of L-mode TLM data to put, add 20131108 Matsuoka
				} else {
					puc_tlm_first = Guc_MGF_TLM_Mmode[uc_mgfoi] ;
				// ^pointer of M-mode TLM data to put, add 20131108 Matsuoka
				}
				puc_tlm = puc_tlm_first + i_sizeData ; // position of next store data, add 20131108 Matsuoka
				// vvv Common header edition
				// v first byte
				*puc_tlm = (uc_mgfoi<<4) + uc_TLM_rate ; // add 20131108 Matsuoka
				// uco[0] = (uc_mgfoi<<4) + uc_TLM_rate ; // delete 20131108 Matsuoka
				// v second byte
				u_long.us[0] = Gus_MGF_Sw_Param_n[uc_mgfoi] ;
				*(puc_tlm+1) = u_long.uc[1] ;  // add 20131108 Matsuoka
				// uco[1] = u_long.uc[1] ;  // delete 20131108 Matsuoka
				// third byte b2 skip
				puc_tlm += 2 ;  // add 20131108 Matsuoka
				i_sizeData += 2 ;  // add 20131108 Matsuoka
				// b3 - b17 common 15 bytes header
				// puc = Guc_MGF_TLM_header_com[uc_mgfoi] ; // pointer of Guc_MGF_TLM_header_com[uc_mgfoi][0]
				// for(i2=0;i2<15;i2++) uco[i2+3] = *(puc++) ;
				// memcpy(&uco[3], Guc_MGF_TLM_header_com[uc_mgfoi], 15) ;  // delete 20131108 Matsuoka
				// b18 - b37 ML 20 bytes header
				// puc = Guc_MGF_TLM_header_ML[uc_mgfoi] ; // pointer of Guc_MGF_TLM_header_ML[uc_mgfoi][0]
				// for(i2=0;i2<20;i2++) uco[i2+18] = *(puc++) ;
				// memcpy(&uco[18], Guc_MGF_TLM_header_ML[uc_mgfoi], 22) ;  // delete 20131108 Matsuoka
				
				if(1==uc_TLM_out) {  // add 20131108 Matsuoka
					// third byte
					*puc_tlm = (1==uc_TLM_rate) ? 1 : Guc_MGF_1s_n[uc_mgfoi] ;  // add 20131108 Matsuoka
					puc_tlm++ ;  // add 20131108 Matsuoka
					// common header 
					memcpy(puc_tlm, Guc_MGF_TLM_header_com[uc_mgfoi], 15) ; // add 20131108 Matsuoka
					puc_tlm += 15 ;  // add 20131108 Matsuoka
					
					if(1==uc_TLM_rate) {  // SPIN
						// third byte
						// uco[2] = 1 ;  // delete 20131108 Matsuoka
						memcpy(puc_tlm, Guc_MGF_TLM_header_ML[uc_mgfoi], 22) ;  // add 20131108 Matsuoka
						i_sizeData += 38 ;  // 1+15+22, add 20131108 Matsuoka
						// us_TLM_test_length = 0 ;  // delete 20131108 Matsuoka
						// puc = Guc_MGF_4hz[uc_mgfoi] ;  // dummy  // delete 20131108 Matsuoka
						// i_sizeData = 0 ;  // delete 20131108 Matsuoka
						if(0==Guc_MGF_TLM_spin_n[uc_mgfoi][i]) Gui_MGF_TLM_ti[uc_mgfoi][i] = Gul_MGF_buff_ti[uc_mgfoi][us_buff] ;  
						// store TI of first spin, add 20131108 Matsuoka
					} else { // (8==uc_TLM_rate) || (4==uc_TLM_rate)
						// ui_dataTi = ul_ml_start_ti ;  // delete 20131108 Matsuoka
						// third byte
						// uco[2] = Guc_MGF_1s_n[uc_mgfoi] ;  // delete 20131108 Matsuoka
						// us_TLM_test_length = uc_TLM_rate * 24 ;  // moved 20131108 Matsuoka
						puc = (8==uc_TLM_rate) ? Guc_MGF_8hz[uc_mgfoi] : Guc_MGF_4hz[uc_mgfoi] ;
						// pointer for Guc_MGF_8hz[uc_mgfoi][0] (when uc_TLM_rate=8)
						//             Guc_MGF_4hz[uc_mgfoi][0] (when uc_TLM_rate=4)
						us_1s_TLM_length = (8==uc_TLM_rate) ? 50 :26 ;
						i_m_mode_l = Guc_MGF_1s_n[uc_mgfoi]*us_1s_TLM_length ;  
						// ^i_sizeData->i_m_mode_l change 20131108 Matsuoka
						// for(i2=us_MGF_TLM_ML_header_length;i2<i_sizeData;i2++) uco[i2] = *(puc++) ;
						// memcpy(&uco[us_MGF_TLM_ML_header_length], puc, i_sizeData) ;  // delete 20131108 Matsuoka
						memcpy(puc_tlm, puc, i_m_mode_l) ;  // add 20131108 Matsuoka
						i_sizeData += (16+i_m_mode_l) ;  // 1+15+i_m_mode_l, add 20131108 Matsuoka
						if(0==Guc_MGF_TLM_spin_n[uc_mgfoi][i]) Gui_MGF_TLM_ti[uc_mgfoi][i] = Gul_MGF_ML_start_ti[uc_mgfoi] + 8 ;
						// ^start TI of first 1s interval, add 20131108 Matsuoka
					}
					
					// i_sizeData += us_MGF_TLM_ML_header_length ;  // delete 20131108 Matsuoka
				}  // match with if(1==uc_TLM_out)
				
				if(2==uc_TLM_out) {  // Test pattern
					us_TLM_test_length = uc_TLM_rate * 16 ;  // 24->16 change 20131108 Matsuoka
					// i_sizeData = us_MGF_TLM_ML_header_length + us_TLM_test_length ;  // delete 20131108 Matsuoka
					i_sizeData += us_TLM_test_length ;  // total length of TLM
					// for(i2=0;i2<us_TLM_test_length;i2++) uco[i2] = i2%(uc_TLM_rate*2) ;  // delete 20131108 Matsuoka
					for(i2=0;i2<us_TLM_test_length;i2++) *(puc_tlm+i2) = i2&0xFF ;  // add 20131108 Matsuoka
				} // match with if(2==uc_TLM_out)
				
				Guc_MGF_TLM_spin_n[uc_mgfoi][i]++ ;  // add 20131108 Matsuoka
				
				if((Guc_MGF_TLM_spin_n[uc_mgfoi][i] >= i_spin[uc_TLM_rate]) || (i_sizeData>i_max_n[uc_TLM_rate])) {  
				 	// defined number of spin period data are stored, add 20131108 Matsuoka

					i_flag = app_PutTlm(
						Gus_MGF_app_m[uc_mgfoi],				// [INPUT]  APP-NUM = 3 (MGF-O) = 13 (MGF-I)
	 					Guc_node_mgf[uc_mgfoi], 				// [INPUT]	Node-ID
						0,										// [INPUT]	Data-ID			// ***** CHANGED!  110721 YK
						Guc_node_mgf[uc_mgfoi],					// [INPUT]	Header-ID (for PID-ID, CAT-ID setting)
						id_hd[i],										// [INPUT]	DR-ID     (for CAT-ID) [0:HK 1:OS 2:L 3:M 4-9:H(0-5)]
						Guc_TLMm_cmp[Guc_node_mgf[uc_mgfoi]], 	// [INPUT]	Comp mode									// ***** CHANGED!  110721 YK
//						0, 	// [INPUT]	Comp mode									// ***** CHANGED!  110721 YK
						uc_pacId, 				// [INPUT]	Packet ID 			<<<< USER-DEF:       0x00-      0xFF >>>>
						Gui_MGF_TLM_ti[uc_mgfoi][i], 	// [INPUT]	Data TI				<<<< USER-DEF: 0x00000000-0xFFFFFFFF >>>>
						uc_comment, 			// [INPUT]	Comment				<<<< USER-DEF: <128B                 >>>>
						uc_sizeComment, 		// [INPUT]	Comment - Size 		<<<< USER-DEF: <128B                 >>>>
						puc_tlm_first, 				// [INPUT]	Data				<<<< USER-DEF: <0x1E00               >>>>
						// uco->puc_tlm_first change 20131108 Matsuoka
						i_sizeData); 			// [INPUT]	Data - Size			<<<< USER-DEF: <0x1E00               >>>>
					Guc_MGF_TLM_spin_n[uc_mgfoi][i] = 0 ;  // initialize, add 20131108 Matsuoka
					i_sizeData = 0 ;  // initialize, add 20131108 Matsuoka
					
				}  // match with if(Guc_MGF_TLM_spin_n[uc_mgfoi][i] >=
				
				Gi_MGF_TLM_data_n[uc_mgfoi][i] = i_sizeData ;  // store data length
			
			}  	// match with if((8==uc_TLM_rate) || (4==uc_TLM_rate) ||
		}  // match with if(0<uc_TLM_out)
	}  // match with for(i=0;i<2;i++)
	
	return ;
}


/************************************************************************************************/
/*************************** MGF ONBOARD DATA PROCESS PART **************************************/
/************************************************************************************************/

void app03_MGF_mss_full_store(unsigned char uc_mgfoi)
{
	int ib ; // counter for block
	int id ; // counter for data in packet
	int ip ; // counter for packet
	unsigned short usdb ;  // data count stored in the buffer
	int i, i2 ;  // data counter in buffer
	int i_buff, i_buff_last ; // counter for buffer
	int k, k2 ;  // counter
	union uni_long {
		long l ;
		unsigned long ul ;
		unsigned short us[2] ;
		unsigned char uc[4] ;
	} u_long ;
	unsigned char *puc, *puc1 ;
	long *pl1, *pl2, *plt1, *plt2 ;
	unsigned short us_buff_n ;
	unsigned long ul_packet_ti ;
	
    i_buff = Gus_MGF_buff_in_store[uc_mgfoi] ; // currently storing buffer
    usdb = Gus_MGF_buff_n[uc_mgfoi][i_buff] ;  // data count already stored in the buffer
    
	for (ib=0; ib<Gl_MGF_mss_block[uc_mgfoi]; ib++) {  // block loop, Gl_MGF_mss_block is number of newly read block
		for(ip=0;ip<Gus_MGF_packet_def_n_in_block;ip++) {  // packet loop, Gus_MGF_packet_def_n_in_block = 9
		
			// puc1 = u_long.uc ;  // pointer for u_long.uc[0]
			// puc2 = Guc_MGF_raw[uc_mgfoi][ib][ip] ;  // pointer for Guc_MGF_raw[uc_mgfoi][ib][ip][0]
			// puc = puc2 + 4 ; // pointer of Guc_MGF_raw[uc_mgfoi][ib][ip][4], first byte of first dT
			// for(k=0;k<4;k++) *(puc1++) = *(puc2++) ;  // data TI store for uc -> long conversion
			memcpy(u_long.uc, Guc_MGF_raw[uc_mgfoi][ib][ip], 4) ;
			
			if(0==u_long.ul) continue ;  // invalid data, skip to next packet
			ul_packet_ti = u_long.ul ;
			
			if(9==Gus_MGF_buff_stat[uc_mgfoi][0]) {  // first entry
				Gul_MGF_buff_ti[uc_mgfoi][0] = ul_packet_ti ;
				Gus_MGF_buff_stat[uc_mgfoi][0] = 0 ;
				
				// conversion parameters
				Gs_MGF_cnv[0][0][2][0] = Gs_MGF_cnv[0][0][2][1] = Gs_MGF_cnv[0][1][2][0] = Gs_MGF_cnv[1][1][0][1] = Gs_MGF_cnv_const_xy ;
				Gs_MGF_cnv[0][1][2][1] = Gs_MGF_cnv[1][0][0][0] = Gs_MGF_cnv[1][0][0][1] = Gs_MGF_cnv[1][1][0][0] = -Gs_MGF_cnv_const_xy ;
				Gs_MGF_cnv[0][2][1][2] = Gs_MGF_cnv[1][2][2][2] = Gs_MGF_cnv_const_z ;
			}
			
			puc = Guc_MGF_raw[uc_mgfoi][ib][ip] + 4 ; // pointer of Guc_MGF_raw[uc_mgfoi][ib][ip][4], first byte of first dT  // moved 20130325
			u_long.l = 0 ; // clear  // added 20130325
			memcpy(&u_long.uc[2], puc, 2) ;  // added 20130325

			if(((ul_packet_ti != Gul_MGF_buff_ti[uc_mgfoi][i_buff]) && (u_long.l<20000)) || (usdb>=Gus_MGF_full_length) ) {  
			  // changed 20130325 to correct the TI of last data in the spin
			 // new TI, next buffer
			 	Gul_MGF_buff_ti[uc_mgfoi][i_buff] = ul_packet_ti ;  // replace TI
				Gus_MGF_buff_n[uc_mgfoi][i_buff] = (us_buff_n = usdb) ;  // data count stored in the buffer
				Gus_MGF_buff_stat[uc_mgfoi][i_buff] = 3 ;  // buffer status = fully stored
				i_buff_last = i_buff ;
				i_buff = (Gus_MGF_buff_in_store[uc_mgfoi] = i_buff_last<2 ? i_buff_last+1 : 0) ;  // new buffer to store
				// now us_buff_n is data number in the last buffer
				usdb = 0 ;  // initialize of data counter in current buffer
				Gus_MGF_buff_stat[uc_mgfoi][i_buff] = 0 ;  // current buffer status = empty
			    k = (us_buff_n < 128) ? us_buff_n : 128 ;
			    Gul_MGF_buff_ti[uc_mgfoi][i_buff] = ul_packet_ti ; // TI of the current buffer // 20130405 add
			    plt1 = Gl_MGF_last_1s_dt[uc_mgfoi][i_buff] ; // pointer for Gl_MGF_last_1s_dt[uc_mgfoi][i_buff][0]
			    plt2 = Gl_MGF_full_dt[uc_mgfoi][i_buff_last] + us_buff_n - k ;
			    // pointer for Gl_MGF_full_dt[uc_mgfoi][i_buff_last][Gus_MGF_buff_n[uc_mgfoi][i_buff_last] - k]
				pl1 = Gl_MGF_last_1s[uc_mgfoi][i_buff][0] ;  // pointer for Gl_MGF_last_1s[uc_mgfoi][i_buff][0][0]
				pl2 = Gl_MGF_full[uc_mgfoi][i_buff_last][us_buff_n - k] ;
				// pointer for Gl_MGF_full[uc_mgfoi][i_buff][Gus_MGF_buff_n[uc_mgfoi][i_buff_last]-k][0]
				for(i=0;i<k;i++) {  // copy of last 1-sec interval data in the last buffer
					*(plt1++) = *(plt2++) ;
					for(k2=0;k2<3;k2++) *(pl1++) = *(pl2++) ;  // axis loop
				}
				Guc_MGF_last_1s_n[uc_mgfoi][i_buff] = k ;
				Gul_MGF_spin_n[uc_mgfoi]++ ;
			}  // match with if((ul_packet_ti != Gul_MGF_buff_ti[uc_mgfoi][i_buff]) ||
			
			// Data copy to Gl_MGF_full_dt and Gl_MGF_full
			// Gul_MGF_buff_ti[uc_mgfoi][i_buff] = ul_packet_ti ; // TI of the current buffer // 20130405 remove
			pl1 = Gl_MGF_full_dt[uc_mgfoi][i_buff] + usdb ; // pointer of Gl_MGF_full_dt[uc_mgfoi][i_buff][usdb]
			pl2 = Gl_MGF_full[uc_mgfoi][i_buff][usdb] ;  // pointer of Gl_MGF_full[uc_mgfoi][i_buff][usdb][0]
			// puc = Guc_MGF_raw[uc_mgfoi][ib][ip] + 4 ; // pointer of Guc_MGF_raw[uc_mgfoi][ib][ip][4], first byte of first dT  // moved before 'if' 20130325
			
			for(id=0;id<Gus_MGF_data_def_n_in_packet;id++) {  //  data loop; Gus_MGF_data_def_n_in_packet = 18
				if(usdb>=Gus_MGF_full_length) break ;  // break from loop for(id=0;id<Gus_MGF_data_def_n_in_packet;id++)
				if((0x08&(*(puc+4))) > 0) {  // puc+4 = 3rd byte of Bx, valid flag check
					// dT copy
					u_long.ul = 0 ; // clear
					puc1 = Guc_MGF_HK[uc_mgfoi] + 1 ;  // pointer of Guc_MGF_HK[uc_mgfoi][1]
					// u_long.uc[2] = (*(puc1++) = *puc) ;
					// u_long.uc[3] = (*(puc1++) = *(puc+1)) ;
					memcpy(&u_long.uc[2], puc, 2) ;
					memcpy(puc1, &u_long.uc[2], 2) ;
					*(pl1++) = u_long.l - Gs_MGF_dt_offset[uc_mgfoi] ;  // dT copy  // 20110902 changed
					// i = 2 ;
					for(i2=0;i2<3;i2++) {  // xyz axis loop
						// for(k=0;k<3;k++) {  // byte loop
						// 	u_long.uc[k+1] = (*(puc1++) = *(puc+i)) ;  // variable store for uc -> long conversion
						// 	i++ ;
						// }
						i = 2 + i2*3 ;
						memcpy(&u_long.uc[1], puc+i, 3) ;
						memcpy(puc1+i, &u_long.uc[1], 3) ;
						// i += 3 ;
						u_long.uc[0] = u_long.uc[1]<128 ? 0 : 0xFF ;  // sign
						*(pl2++) = u_long.l ;
					}  // match with for(i2=0;i2<3;i2++) {
					Gus_MGF_buff_stat[uc_mgfoi][i_buff] = 1 ; // partially stored
					usdb++ ;  // increment of the data counter in the buffer
				}  // match with if((0x08&(*(puc+4))) > 0)
				puc += 11 ;  // next data
			}  // match with for(id=0;id<Gus_MGF_data_def_n_in_packet;id++)
		}  // match with for(ip=0;
	}  // match with for (ib=0;
	
	Gus_MGF_buff_n[uc_mgfoi][i_buff] = (u_long.us[0] = usdb) ;  // store of the data number in the buffer
	return ;
}


void app03_MGF_mss_process( unsigned char uc_mgfoi) 
{
	unsigned long ul_ti_s ;
	unsigned short us ;
	unsigned short us_bf ; // fully-stored oldest buffer index
	unsigned short us_b, us_b_next ;  // buffer counter
	
	us_bf = 9 ;
	ul_ti_s = 0xFFFFFFFF ;
	// find fully-stored oldest buffer
	for(us=0;us<3;us++) {
		if((3==Gus_MGF_buff_stat[uc_mgfoi][us]) &&  (Gul_MGF_buff_ti[uc_mgfoi][us] < ul_ti_s)) {
			ul_ti_s = Gul_MGF_buff_ti[uc_mgfoi][us] ;
			us_bf = us ;
		}
	}
	
	if(9==us_bf) return ;
	
	for(us=us_bf;us<us_bf+3;us++) {
		us_b = us%3 ; 
		us_b_next = (us+1)%3 ; 
		if((3==Gus_MGF_buff_stat[uc_mgfoi][us_b])&&(0<Gus_MGF_buff_stat[uc_mgfoi][us_b_next])) {
		// fully stored, next buffer stored partially or fully
			if(16<Gus_MGF_buff_n[uc_mgfoi][us_b]) {
				app03_MGF_average(uc_mgfoi,us_b) ;
				app03_MGF_def_shift(uc_mgfoi,us_b) ;
				app03_MGF_spin_fit(uc_mgfoi,us_b) ;
				app03_MGF_TLM_header(uc_mgfoi,us_b) ;
				app03_MGF_every_1s_process(uc_mgfoi,us_b) ;
				app03_MGF_put_TLM_HML(uc_mgfoi, us_b) ;  // add us_b 110915
			}
			Gus_MGF_buff_stat[uc_mgfoi][us_b] = 0 ;  // buffer status clear
			Gus_MGF_buff_n[uc_mgfoi][us_b] = 0 ;  // buffer data number clear
			Guc_MGF_last_1s_n[uc_mgfoi][us_b] = 0 ;  // buffer data number clear
		}  // match with if(3==Gus_MGF_buff_stat[uc_mgfoi][ib])
	}  // match with for(i=ibf;
	
	return ;
}


void app03_MGF_average(unsigned char uc_mgfoi, unsigned short us_buff)
{
	unsigned short us, usn ;
	long l_sum[3] ;
	long *pl ;
	int i ;

	usn = Gus_MGF_buff_n[uc_mgfoi][us_buff] ;  // data number stored in the buffer

	for(i=0;i<3;i++) l_sum[i] = 0 ;  // initialize
	
	pl = Gl_MGF_full[uc_mgfoi][us_buff][0] ; // pointer for Gl_MGF_full[uc_mgfoi][us_buff][0][0]
	for(us=0;us<usn;us++) {
		for(i=0;i<3;i++) l_sum[i] += *(pl++)/16 ;  // 4 bits shift
	}
	
	pl = Gl_MGF_ave[uc_mgfoi] ;  // pointer for Gl_MGF_ave[uc_mgfoi][0]
	if(usn>0) {
		for(i=0;i<3;i++) *(pl++) = (l_sum[i]/usn)<<4 ;  // 110915
	} else {
		for(i=0;i<3;i++) *(pl++) = 0 ;
	}

	return ;
}


void app03_MGF_def_shift(unsigned char uc_mgfoi, unsigned short us_buff)
{
	unsigned short us, usn, usn2 ;
	int ix ;
	long l_tmp, l_rng_max ;
	long *pl1, *pl2 ;
	unsigned short us_shift ;
	
	union uni_long {
		long l ;
		unsigned char uc[4] ;
	} u_long ;
	
	usn2 = Guc_MGF_last_1s_n[uc_mgfoi][us_buff] ;  // data number stored in the last 1s buffer
	usn = Gus_MGF_buff_n[uc_mgfoi][us_buff] ;  // data number stored in the buffer
	
	// major component in this spin
	for(ix=0;ix<3;ix++) {
		 u_long.l = (0<Guc_MGF_mjr_flag[uc_mgfoi][ix])? Gl_MGF_ave[uc_mgfoi][ix] : Gl_MGF_sub[uc_mgfoi][ix] ;
		 u_long.uc[3] = 0 ;  // lowest byte clear
		 Gl_MGF_mjr[uc_mgfoi][ix] = u_long.l ;
	}

	// subtraction of major component
	pl1 = Gl_MGF_last_1s[uc_mgfoi][us_buff][0] ;  // Gl_MGF_last_1s[uc_mgfoi][us_buff][0][0]
	for(us=0;us<usn2;us++) {
		pl2 = Gl_MGF_mjr[uc_mgfoi] ;  // pointer for Gl_MGF_mjr[uc_mgfoi][0]
		for(ix=0;ix<3;ix++) *(pl1++) -= *(pl2++) ;  // subscription of major component
	}
	pl1 = Gl_MGF_full[uc_mgfoi][us_buff][0] ;  // pointer for Gl_MGF_full[uc_mgfoi][us_buff][0][0]
	for(us=0;us<usn;us++) {
		pl2 = Gl_MGF_mjr[uc_mgfoi] ;  // pointer for Gl_MGF_mjr[uc_mgfoi][0]
		for(ix=0;ix<3;ix++) *(pl1++) -= *(pl2++) ;  // subscription of major component
	}

	for(ix=0;ix<3;ix++) {
		if(4>=Guc_MGF_shift_flag[uc_mgfoi][ix]) {  // fixed shift
			Gus_MGF_rng_shift[uc_mgfoi][ix] = Guc_MGF_shift_flag[uc_mgfoi][ix] ;
		} else {  // automatic shift
			l_rng_max =0 ;
			for(us=0;us<usn2;us++) {
				l_tmp = Gl_MGF_last_1s[uc_mgfoi][us_buff][us][ix];  // using pointer did not reduce the size 110914
				if(l_tmp<0) l_tmp *= -1 ;
				l_rng_max = (l_tmp>l_rng_max) ? l_tmp : l_rng_max ;
			}
			for(us=0;us<usn;us++) {
				l_tmp = Gl_MGF_full[uc_mgfoi][us_buff][us][ix];  // using pointer did not reduce the size 110914
				if(l_tmp<0) l_tmp *= -1 ;
				l_rng_max = (l_tmp>l_rng_max) ? l_tmp : l_rng_max ;
			}
			us_shift = 0; // initialize
			if(l_rng_max>=0x080000) us_shift = 1 ;
			if(l_rng_max>=0x100000) us_shift = 2 ;
			if(l_rng_max>=0x200000) us_shift = 3 ;
			if(l_rng_max>=0x400000) us_shift = 4 ;
			Gus_MGF_rng_shift[uc_mgfoi][ix] = us_shift ;  // store
		}  // match with if(4>=Guc_MGF_shift_flag[uc_mgfoi][ix])
	} // match with for(ix=0;ix<3;ix++)
	
	return ;
}


void app03_MGF_spin_fit(unsigned char uc_mgfoi, unsigned short us_buff)
{
	unsigned short us, usn, us_buff_next ;
	int i, i2, i_err ;
	long l_w ;
	long l_sin_s[3], l_cos_s[3], l_a[3], l_b[3], l_rms_v[3], l_rms, l_dcb[3], l_d_ave[3] ;
	// unsigned int	ui_TrgTi;							// removed!   by YK  121125
	long *pl, *pl2 ;
	short *ps, *ps1 ;
	#ifdef TLM_STAT
	unsigned char *puc1 ;
	#endif

	union uni_long {
		long l ;
		unsigned long ul ;
		short s[2] ;
		unsigned short us[2] ;
		unsigned char uc[4] ;
	} u_long ;
	
	short s_b[3], s_rms ;

	double d_ang, d_sin, d_cos, d_x ;
	
	usn = Gus_MGF_buff_n[uc_mgfoi][us_buff] ;  // data number stored in the buffer

	if(usn<1) { // no data in this spin
		return ;
	}

	// Spin Period
    us_buff_next = us_buff<2 ? us_buff+1 : 0 ;
    l_w = Gl_MGF_full_dt[uc_mgfoi][us_buff][usn-1] + Gus_MGF_t_step[uc_mgfoi] - Gl_MGF_full_dt[uc_mgfoi][us_buff_next][0] ;

	if((0>=l_w) || 0xFFFF<=l_w) l_w = Gl_MGF_full_dt[uc_mgfoi][us_buff][usn-1] ;
	
	if((0>=l_w) || 0xFFFF<=l_w) l_w = 4000000/Gus_MGF_dt_unit[uc_mgfoi] ;
	
	Gul_MGF_spin_prd[uc_mgfoi] = (unsigned long) l_w ;
	
	for(i=0;i<3;i++) {
		// initialize for the summation
		l_sin_s[i] = 0 ;
		l_cos_s[i] = 0 ;
		// numbers to correct (full-mjr) to (full-ave)
		u_long.l = (Gl_MGF_mjr[uc_mgfoi][i] - Gl_MGF_ave[uc_mgfoi][i]) <<8 ;
		l_d_ave[i] = (long) u_long.s[0] ;
	}
	
	pl2 = Gl_MGF_full_dt[uc_mgfoi][us_buff] ;  // pointer for Gl_MGF_full_dt[uc_mgfoi][us_buff][0]
	pl = Gl_MGF_full[uc_mgfoi][us_buff][0] ;  // pointer for Gl_MGF_full[uc_mgfoi][us_buff][0][0]
	for(us=0;us<usn;us++) {
		// s_ang = *(pus++) * 1440/Gul_MGF_spin_prd[uc_mgfoi] ;
		// app03_MGF_sin (s_ang, &l_sin,  &l_cos) ;
		d_ang = (double) (*(pl2++)) ;
		d_ang *= 2*MATH_PI ;
		d_ang /= Gul_MGF_spin_prd[uc_mgfoi] ;
		d_sin = app_math_sin(d_ang) ;  // 111007
		d_cos = app_math_cos(d_ang) ;  // 111007
		for(i=0;i<3;i++) {  // MGF axis loop
			l_w = (*(pl++)) /16 ;  // 4 bit shift
			// sin part
			d_x = l_w * d_sin ;
			l_sin_s[i] += (long) d_x ;  // summation
			// cos part
			d_x = l_w * d_cos ;
			l_cos_s[i] += (long) d_x ;  // summation
		}
	}
	
	for(i=0; i<3; i++) l_rms_v[i] = 0 ;  // initialize of rms
	
	// calculation of coefficients a and b
	for(i=0; i<3; i++) {  // MGF axis loop
		l_a[i] = l_sin_s[i] /usn /8 ;  // x(2/usn), 4 bit shift
		l_w = 0x00018000 & l_a[i] ;
		if((0x00010000==l_w) || (0x00008000==l_w)) l_rms_v[i] = 0xFFFFFFF ;  // 0x00010000 -> 0x00008000 correction 20131108 Matsuoka
		l_b[i] = l_cos_s[i] /usn /8 ;  // x(2/usn), 4 bit shift
		l_w = 0x00018000 & l_b[i] ;
		if((0x00010000==l_w) || (0x00008000==l_w)) l_rms_v[i] = 0xFFFFFFF ;
		u_long.l = (Gl_MGF_ave[uc_mgfoi][i]<<8) ;
		l_dcb[i] = (long) (u_long.s[0] - Gs_MGF_off[uc_mgfoi][i]) ;
	}  // match with for(i=0; i<3; i++)
	
	// RMS calculation

	pl2 = Gl_MGF_full_dt[uc_mgfoi][us_buff] ; // pointer for Gl_MGF_full_dt[uc_mgfoi][us_buff][0]
	pl = Gl_MGF_full[uc_mgfoi][us_buff][0] ; // pointer for Gl_MGF_full[uc_mgfoi][us_buff][0][0]
	for(i=0;i<usn;i++) {
		d_ang = (double) (*(pl2++)) ;
		d_ang *= 2*MATH_PI ;
		d_ang /= Gul_MGF_spin_prd[uc_mgfoi] ;
		d_sin = app_math_sin(d_ang) ;  // 111007
		d_cos = app_math_cos(d_ang) ;  // 111007

		for(i2=0;i2<3;i2++) {  // axis loop
			l_w = (*(pl++)) >> 8 ; // 8 bit shift
			if(l_rms_v[i2]<0xFFFFFFF) {
				d_x = l_a[i2]*d_sin + l_b[i2]*d_cos ; /* 20120605 */
				u_long.l = l_w ;  // Gl_MGF_full >> 8
				l_w = (long) u_long.s[1] + l_d_ave[i2] ; // corrected to full-ave
				l_rms = (u_long.l = l_w - ((long) d_x)) ;
				if(u_long.uc[0]>=0x80) l_rms *= -1 ;  // negative
				l_rms_v[i2] += l_rms ;
			} // match with if(l_rms_v[i2]<0xFFFFFFF)
		} // match with for(i2=0;i2<3;i2++)
		
	}  // match with for(i=0;i<usn;i++)
	
	for(i=0; i<3; i++) {
		if(l_rms_v[i]<0xFFFFFFF) l_rms_v[i] /= usn ;  // average
	}
	
	// input to Gs_MGF_spin_fit
	ps = Gs_MGF_spin_fit[uc_mgfoi][0] ; // pointer of Gs_MGF_spin_fit[uc_mgfoi][0][0]
	for(i=0;i<3;i++) {  // axis loop
		u_long.l = l_a[i] ;
		*(ps++) = u_long.s[1] ;
		u_long.l = l_b[i] ;
		*(ps++) = u_long.s[1] ;
		u_long.l = l_rms_v[i] ;
		*(ps++) = u_long.s[1] ;
	}
	
	// TRIGGER values calculation
	
	#ifdef TLM_STAT
	// copy to TLM_stat
	puc1 = &Guc_MGF_TLM_stat[uc_mgfoi][14] ;
	ps = Gs_MGF_cnv[uc_mgfoi][0][0] ;  // pointer of Gs_MGF_cnv[uc_mgfoi][0][0][0]
	for(i=0;i<27;i++) {
		u_long.s[0] = *(ps++) ;
		memcpy(puc1, u_long.uc, 2) ;
		puc1 += 2 ;
	}
	ps = Gs_MGF_off[uc_mgfoi] ;  // pointer of Gs_MGF_off[uc_mgfoi][0]
	for(i=0;i<3;i++) {
		u_long.s[0] = *(ps++) ;
		memcpy(puc1, u_long.uc, 2) ;
		puc1 += 2 ;
	}
	#endif
	
	i_err = 0 ; // initialize of error flag
	ps1 = Gs_MGF_TRG[uc_mgfoi] ;  // pointer of Gs_MGF_TRG[uc_mgfoi][0]
	for(i=0; i<3; i++) { // S/C coordinate axis loop
	    ps = Gs_MGF_cnv[uc_mgfoi][i][0] ;  // pointer of Gs_MGF_cnv[uc_mgfoi][i][0][0]
	    // Gs_MGF_cnv[uc_mgfoi][sc x/y/z][mgf x/y/z][sin(a)/cos(b)/dcb]
	    l_w = 0 ;  // initialize
	    for(i2=0; i2<3; i2++) {  // MGF axis loop
	    	l_w += l_a[i2]*((long) (*(ps++))) ;
	    	l_w += l_b[i2]*((long) (*(ps++))) ;
	    	l_w += l_dcb[i2]*((long) (*(ps++))) ;
	    	if(0xFFFFFFF==l_rms_v[i2]) i_err = 1 ;
	    }
	    
	    // for Trigger variable
	    l_w = u_long.l = (l_w>>14) ;
	    l_w = 0x00038000 & l_w ;
	    if((0x00000000!=l_w) && (0x00038000!=l_w)) i_err = 1 ;
	    *(ps1++) = s_b[i] = u_long.s[1] ;  // lower 16 bits
	}  // match with for(i=0; i<3; i++)
	
	if(0==i_err) {
		u_long.l = (l_rms_v[0]+l_rms_v[1]+l_rms_v[2])/3 ;
		s_rms = *ps1 = u_long.s[1] ;
	} else {
		s_rms = *ps1 = 0xFFFF ;
	}
	
	/* **** removed: by YK 121121 ****
	for(i=0 ;i<Gd_TRG_MAX ;i++) {												
		if ( uc_mgfoi == 0 ) 	ui_TrgTi = Gui_TRG1_SpTI_s[i];			// MGF-O
		else					ui_TrgTi = Gui_TRG2_SpTI_s[i];			// MGF-I
		if (Gul_MGF_buff_ti[uc_mgfoi][us_buff]>=ui_TrgTi-512) {
			if (Gul_MGF_buff_ti[uc_mgfoi][us_buff]<=ui_TrgTi+512) {  	// +- 1sec
				break ; // break from for loop
			}
		}
	}  // match with for(i=0 ;i<Gd_TRG_MAX ;i++)
	*/
	
	#ifdef TLM_STAT
	// store in TLM_stat  20120605
	u_long.ul = Gul_MGF_buff_ti[uc_mgfoi][us_buff] ;
	memcpy(&Guc_MGF_TLM_stat[uc_mgfoi][2], u_long.uc, 4) ;
	for(i=0;i<3;i++) {  // axis loop
		u_long.s[0] = s_b[i] ;
		memcpy(&Guc_MGF_TLM_stat[uc_mgfoi][6+i*2], u_long.uc, 2) ;
	}
	u_long.s[0] = s_rms ;
	memcpy(&Guc_MGF_TLM_stat[uc_mgfoi][12], u_long.uc, 2) ;
	#endif
	
	// *** TRIGGER VARIABLE input ***																		// ADDED!   by YK 121125
	if ( uc_mgfoi == 0 ) 	i = app_tiTrgSearch( Gul_MGF_buff_ti[uc_mgfoi][us_buff], Gd_N_MGFO );			// ADDED!   by YK 121125
	else					i = app_tiTrgSearch( Gul_MGF_buff_ti[uc_mgfoi][us_buff], Gd_N_MGFI );			// ADDED!   by YK 121125
	if (i)	{																								// ADDED!   by YK 121125
		if(0==uc_mgfoi) {  	// MGF-O																		// ADDED!   by YK 121125
				Gs_TRG1_MGFO_Bx   [i] = s_b[0] ;															// CHANGED! by YK 110721
				Gs_TRG1_MGFO_By   [i] = s_b[1] ;															// CHANGED! by YK 110721
				Gs_TRG1_MGFO_Bz   [i] = s_b[2] ;															// CHANGED! by YK 110721
				Gus_TRG1_MGFO_Brms[i] = s_rms ;																// CHANGED! by YK 110721
		} else {			// MGF-I																		// CHANGED! by YK 121125
				Gs_TRG2_MGFI_Bx   [i] = s_b[0] ;															// CHANGED! by YK 110721
				Gs_TRG2_MGFI_By   [i] = s_b[1] ;															// CHANGED! by YK 110721
				Gs_TRG2_MGFI_Bz   [i] = s_b[2] ;															// CHANGED! by YK 110721
				Gus_TRG2_MGFI_Brms[i] = s_rms ;																// CHANGED! by YK 110721
		}																									// ADDED!   by YK 121125
	}																										// ADDED!   by YK 121125

	return ;
}


void app03_MGF_TLM_header(unsigned char uc_mgfoi, unsigned short us_buff)
{
	union uni_long {
		long l ;
		unsigned long ul ;
		short s[2] ;
		unsigned short us[2] ;
		unsigned char uc[4] ;
	} u_long ;
	int i ;
	unsigned char uc1 ;
	unsigned char *puc1 ;
	long *pl ;
	short *ps ;
	unsigned short *pus ;

	unsigned short us_sw_param_n ;

	// TLM packet header edition
	
	// Common header 15 bytes
	// Major component (2B) & bit shift
	pl = Gl_MGF_mjr[uc_mgfoi] ;  // pointer for Gl_MGF_mjr[uc_mgfoi][0] ;
	puc1 = Guc_MGF_TLM_header_com[uc_mgfoi] ;  // pointer for Guc_MGF_TLM_header_com[uc_mgfoi][0]
	pus = Gus_MGF_rng_shift[uc_mgfoi] ;  // pointer for Gus_MGF_rng_shift[uc_mgfoi][0]
	// X, Y, Z
	for(i=0;i<3;i++) {
		u_long.l = *(pl++) ;
		// puc2 = u_long.uc ;  // pointer for u_long.uc[0]
		// *(puc1++) = u_long.uc[1] ;  // 110915
		// *(puc1++) = u_long.uc[2] ;  // 110915
		memcpy(puc1, &u_long.uc[1], 2) ;
		puc1 += 2 ;
		uc1 = ((Guc_MGF_mjr_flag[uc_mgfoi][i]<<4)&0xF0) ;
		u_long.us[0] = *(pus++) ; // Gus_MGF_rng_shift
		uc1 += ((Guc_MGF_shift_flag[uc_mgfoi][i]&0x08) + u_long.uc[1]);  /* 20120605 */
		*(puc1++) = uc1 ;
	}

    // TI of the spin
	u_long.ul = Gul_MGF_buff_ti[uc_mgfoi][us_buff] ;
	// puc2 = u_long.uc ; // pointer for u_long.uc[0]
	// for(i=0;i<4;i++) *(puc1++) = *(puc2++) ;
	memcpy(puc1, u_long.uc, 4) ;
	puc1 += 4 ;

	// spin period
	u_long.ul = Gul_MGF_spin_prd[uc_mgfoi] ;
	// puc2 = u_long.uc + 2 ; // pointer for u_long.uc[2]
	// for(i=0;i<2;i++) *(puc1++) = u_long.uc[i+2] ;
	memcpy(puc1, &u_long.uc[2], 2) ;
	
	// ML header 22 bytes
	// ML header counter
	us_sw_param_n = Gus_MGF_Sw_Param_n[uc_mgfoi] + 1 ;
	// us_sw_param_n++ ;
	if(us_sw_param_n>=36) us_sw_param_n = 0 ;  // reset
	Gus_MGF_Sw_Param_n[uc_mgfoi] = us_sw_param_n ;

	// Software Parameters in header
	if(us_sw_param_n<27) {
		u_long.s[0] = (*(Gs_MGF_cnv[uc_mgfoi][0][0] + us_sw_param_n)) ;
		// Gus_MGF_Sw_Param_n[uc_mgfoi]-th parameter in array Gs_MGF_cnv[uc_mgfoi][3][3][3]
	} else if(us_sw_param_n<30) {
		i = us_sw_param_n-27 ;
		u_long.s[0] = Gs_MGF_off[uc_mgfoi][i] ;  // i = 0, 1, 2
	} else if(us_sw_param_n<31) {  //  us_sw_param_n = 30
		u_long.s[0] = Gs_MGF_dt_offset[uc_mgfoi] ;
	}
	
	puc1 = Guc_MGF_TLM_header_ML[uc_mgfoi] ;
	// Guc_MGF_TLM_header_ML[uc_mgfoi][0] = u_long.uc[i] ;
	// Guc_MGF_TLM_header_ML[uc_mgfoi][1] = u_long.uc[i+1] ;
	memcpy(puc1, u_long.uc, 2) ;
	puc1+= 2 ;
	
	// data number in the spin
	u_long.us[0] = Gus_MGF_buff_n[uc_mgfoi][us_buff] ;
	memcpy(puc1, u_long.uc, 2) ;
	puc1+= 2 ;
	
	// Spin fit result
	ps = Gs_MGF_spin_fit[uc_mgfoi][0] ; // pointer of Gs_MGF_spin_fit_a[uc_mgfoi][0][0]
	for(i=0;i<9;i++) { // axis * (a, b, rem)  loop
		u_long.s[0] = *(ps++) ;
		// *(puc1++) = u_long.uc[0] ;
		// *(puc1++) = u_long.uc[1] ;
		memcpy(puc1, u_long.uc, 2) ;
		puc1 += 2 ;
	}

	return ;
}


void app03_MGF_every_1s_process(unsigned char uc_mgfoi, unsigned short us_buff)
{
	int i, i2 ;
	int id ; // data index in the buffer
	int nd ;  // data counter in 1-sec interval
	int n_1s ;  // 1-sec interval counter
	long l_ti_equ, l_s[3], l_s_save[3] ;
	unsigned short us_ti_step_1hz ;
	unsigned short us_dt_unit ; 
	unsigned long ul_1hz_ti, ul_buff_ti ;
	unsigned short us_shift[3] ;
	unsigned char *puc1, *puc2 ;
	long *pl, *pl1, *pl2, *pl3, *pl4, *pl10, *pl30 ;
	unsigned short *pus ;
	
	union uni_long {
		long l ;
		unsigned long ul ;
		short s[2] ;
		unsigned char uc[4] ;
	} u_long ;
	
	long l_1s_b[136][3] ;
	long l_1s_dt[136] ;  // changed from us to long 20110903

	n_1s = 0  ; // initialize of 1-sec interval counter
	nd = 0 ;  // initialize of data number in 1-sec storage
	
	us_ti_step_1hz = Gus_MGF_ti_step_1hz ;
	ul_buff_ti = Gul_MGF_buff_ti[uc_mgfoi][us_buff] ;
	us_dt_unit = Gus_MGF_dt_unit[uc_mgfoi] ;
	
	ul_1hz_ti = (ul_buff_ti/us_ti_step_1hz)*us_ti_step_1hz ;  // initial 1hz TI
	
	Gul_MGF_ML_start_ti[uc_mgfoi] = ul_1hz_ti ;
	
	pus = Gus_MGF_rng_shift[uc_mgfoi] ;  // pointer of Gus_MGF_rng_shift[uc_mgfoi][0]
	for(i=0;i<3;i++) us_shift[i] = (*(pus++)) + 4 ;  // copy to local variable
	
    // storing data in last 1-sec data buffer
	pl2 = Gl_MGF_last_1s_dt[uc_mgfoi][us_buff] ; // pointer of Gl_MGF_last_1s_dt[uc_mgfoi][us_buff][0]
	pl = Gl_MGF_last_1s[uc_mgfoi][us_buff][0] ; // pointer for Gl_MGF_last_1s[uc_mgfoi][us_buff][0][0]
	pl1 = pl10 = l_1s_dt ;  // pointer of l_1s_dt[0]
	pl3 = pl30 = l_1s_b[0] ; // pointer of l_1s_b[0][0]
	
	for(id=0;id<Guc_MGF_last_1s_n[uc_mgfoi][us_buff];id++) {
		// equivalent TI
		l_ti_equ = ul_buff_ti - (Gul_MGF_spin_prd[uc_mgfoi] - (*pl2))*us_dt_unit/Gus_MGF_ti_unit ;
		if(l_ti_equ<ul_1hz_ti) {
			pl2++ ;
			pl += 3 ;
			continue ;  // skip to next loop
		}
		
		*(pl1++) = *(pl2++) ;  // copy of dT
		// B data copy Gl_MGF_last_1s -> l_1s_b
		for(i=0;i<3;i++) *(pl3++) = (*(pl++)) ;  // axis loop
		nd++ ;  // increment of data counter in 1-sec interval
	}  // match with for(id=0;id<Guc_MGF_last_1s_n[uc_mgfoi][us_buff];id++)
	
	// averaging of current buffer every second
	pl2 = Gl_MGF_full_dt[uc_mgfoi][us_buff] ;  // pointer of Gl_MGF_full_dt[uc_mgfoi][us_buff][0]
	pl =  Gl_MGF_full[uc_mgfoi][us_buff][0] ;  // pointer for  Gl_MGF_full[uc_mgfoi][us_buff][0][0]
	
	for(id=0;id<Gus_MGF_buff_n[uc_mgfoi][us_buff];id++) {
		// id : index for current buffer
		// nd : index for l_1s_dt and l_1s_b

		// equivalent TI
		l_ti_equ = ul_buff_ti + (*pl2)*us_dt_unit/Gus_MGF_ti_unit ;
		if(l_ti_equ<ul_1hz_ti) {
			pl2++ ;
			pl  += 3 ;
			continue ; // skip to next loop
		}

		*(pl1++) = *(pl2++) ;  // copy of dT
		
		// B data copy Gl_MGF_full -> l_1s_b
		for(i=0;i<3;i++) *(pl3++) = (*(pl++)) ;  // axis loop
		nd++ ;  // increment of data counter in 1-sec interval

		// if(l_ti_equ>=(ul_1hz_ti+us_ti_step_1hz)) { // 1-sec data ready
		// if((l_ti_equ>=(ul_1hz_ti+us_ti_step_1hz)) || (nd>130)) { // 1-sec data ready 120607
		if((l_ti_equ>=(ul_1hz_ti+us_ti_step_1hz)) || (nd>130) || (((id+1)==Gus_MGF_buff_n[uc_mgfoi][us_buff])&&(nd>=127))) { // 1-sec data ready 170325
			puc1 = Guc_MGF_8hz[uc_mgfoi] + n_1s*50 ; // pointer for Guc_MGF_8hz[uc_mgfoi][n_1s*50]
			// 50 : length of averaged data for 1-sec interval : 2bytes + 6bytes * 8Hz
			puc2 = Guc_MGF_4hz[uc_mgfoi] + n_1s*26 ; // pointer for Guc_MGF_4hz[uc_mgfoi][n_1s*26]
			// 26 : length of averaged data for 1-sec interval : 2bytes + 6bytes * 4Hz
			u_long.ul = ul_1hz_ti ;
			*(puc1++) = (*(puc2++) = u_long.uc[2]) ;  // 3th byte of 1Hz TI
			u_long.ul = nd ;
			*(puc1++) = (*(puc2++) = u_long.uc[3]) ;  // number of data in 1sec interval
			// averaging
			// if(nd>=128) nd=128 ;  // remove 170325
			for(i2=0;i2<3;i2++) l_s[i2] = 0 ;  // initialize
			pl4 = pl30 ;  // pointer of l_1s_b[uc_mgfoi][0][0]
			// for(i=0;i<nd;i++) {  // loop data in 1sec interval, remove 170325
			for(i=0;i<128;i++) {  // loop data in 1sec interval 170325
				// for(i2=0;i2<3;i2++) l_s[i2] += *(pl4++) ;  // summation, axis loop, remove 170325
				for(i2=0;i2<3;i2++) {  // 170325
					l_s[i2] += *(pl4) ;  // summation, axis loop 170325
					if(i<nd-1) pl4++ ;  // not last data 170325
				}
				if(15==i%16) {  // 8Hz ; 16 = 128Hz / 8Hz
					for(i2=0;i2<3;i2++) {  // axis loop
						l_s[i2] /= 16 ;  // average
						u_long.l = (l_s[i2] >> us_shift[i2]) ;  // bit shift
						memcpy(puc1, &u_long.uc[2], 2) ;  // 8Hz data store
						puc1 += 2 ;
					}
					if(31==i%32) { // 4Hz ; 32 = 128Hz / 4Hz
						for(i2=0;i2<3;i2++) {  // axis loop
							u_long.l = ((l_s[i2] + l_s_save[i2])/2) >> us_shift[i2] ; // average two 8Hz data
							memcpy(puc2, &u_long.uc[2], 2) ;  // 4Hz data store
							puc2 += 2 ;
						}
					}  // match with if(31==i%32)
					for(i2=0;i2<3;i2++) l_s_save[i2] = l_s[i2] ;
					for(i2=0;i2<3;i2++) l_s[i2] = 0 ;  // initialize
				}  // match with if(15==i%16)
			} // match with for(i=0;i<nd;i++)
			n_1s++ ;  // increment of 1s data counter
			ul_1hz_ti += us_ti_step_1hz ;
			nd = 1 ;  // initialize of 128Hz data counter in 1s interval
			l_1s_dt[0] = *(pl1-1) ;
			for(i2=0;i2<3;i2++) l_1s_b[0][i2] = *(pl3-3+i2) ;
			pl1 = pl10 ;  // pointer initialize to l_1s_dt[0]
			pl3 = pl30 ;  // pointer initialize to l_1s_b[0][0]
		}  // match with if(l_ti_equ>=(ul_1hz_ti+us_ti_step_1hz))
		
		if(n_1s>6) break ;
	}  	// match with for(id=ids3;id<Gus_MGF_buff_n[uc_mgfoi][us_buff];id++)

	u_long.l = n_1s ;
	Guc_MGF_1s_n[uc_mgfoi] = u_long.uc[3] ;
	
	return ;
}