/*******************************************************************************
*   モジュール名称      ：APP01 - CMD from DMC to DPU (for 'ENA' task)         *
*   作成日・作成者      ：2011/11/27    Y.K.                                   *
*                                                                              *
*   参照                ：  app01_DPU.c を参照のこと                           *
*   注意				：  EDIT権限は、MPPE/ENA組                             *
********************************************************************************/
#include	"app_MPPE-ENA.h"

#ifdef	d_ENA_LOCAL_EMU
  #include "if_emulator.h"
#endif

// *** Prototype - ENA ***
unsigned char	app01_ENA             ( unsigned int,  unsigned char * , int);
//
unsigned char	app01_InitVar_ENA     ( void );
// unsigned char	app01_ErrClr_ENA      ( void );			**** comment out by YK 111127 ****



// **************************************
// *** ENA: CMD analyses / execution ***
// **************************************
unsigned char	app01_ENA  ( unsigned int ui_Cntl, unsigned char uc_Data[], int i_Size )
{
	return app01_ENA_2(ui_Cntl, uc_Data, i_Size, TRUE);
}


unsigned char app01_ENA_2(unsigned int ui_Cntl, unsigned char uc_Data[], int i_Size, unsigned char uc_extcmd)
// uc_extcmd: TRUE:  外部からのコマンド (コマンドカウンタをインクリメントするなど)
//            FALSE: ソフトウェア内からのコマンド (コマンドカウンタはインクリメントしないなど)
{
	char			c;
	unsigned char	uc_flag = 0xff;
	unsigned char	uc, uc_id, uc_flg2, uc_flg3, uc_flg4;
	unsigned char	ucch, ucen, ucph, ucma, uc_lenph, uc_startph;
	unsigned char	*puc;
	unsigned char	uc_buf[d_Lcl_ENA_SensorCMD_MaxLen];		// センサーへのコマンド用バッファ
	unsigned short	us_adr_s;
	int				i;

	switch (ui_Cntl) {
		// --------------------------------------------------------
		// ----- Admin --------------------------------------------
		// --------------------------------------------------------

		case 0x0000:
//			if (i_Size!=0) return(0xFF);
			if (i_Size != 0) break;
			uc_flag = app01_InitVar_ENA();							// MD*U_ENA_INIT
			break;

/*			***** comment out by YK		111127 *****
		case 0x0001:
//			if (i_Size!=0) return(0xFF);
			if (i_Size != 0) break;
			uc_flag = app01_ErrClr_ENA ();							// MD*U_ENA_ERR_CLR
			break;
*/
		
		// IFE へのコマンド
		case d_Lcl_ENA_CMD_toSensor:
			if(i_Size < 1){ break; }
			
			uc_flag = app_PiCmd(Gd_N_ENA, uc_Data, i_Size);

			break;

		// マクロコマンド実行リクエスト (引数: macro command table ID, macro command ID)
		case d_Lcl_ENA_CMD_MacroREQ:

			// 他のコマンドが実行中だった時の対応は必要?
			
			if(i_Size < 2){ break; }
			
			if(Gs_ENA_prm.s_MacroCmd.uc_cmdenaflg == FALSE) { break; }
			
			Gs_ENA_prm.s_MacroCmd.uc_cmdenaflg = FALSE;				// マクロコマンド実行要求受付 enable フラグをおろす
			
			
			// uc_Data[0]: マクロコマンドテーブルID。 サイズは d_Lcl_ENA_MACROCMDTbl_size
			// uc_Data[1]: 選択されたマクロコマンドテーブル内で実行するマクロコマンド ID
			if( ! app01_ENA_MacroCmdTblSet(Guc_ENA_MacroCmd_Tbl, uc_Data[0]) ){
				break;
			}
			Gs_ENA_prm.s_MacroCmd.s_mcp.us_macroID		= uc_Data[1];			// 選択されたマクロコマンドテーブル内で
																				//   実行するマクロコマンド ID
			Gs_ENA_prm.s_MacroCmd.s_mcp.puc_macrotbl	= Guc_ENA_MacroCmd_Tbl;
			
			c = (char)app_macrocmd_cont(Gd_N_ENA, &(Gs_ENA_prm.s_MacroCmd.s_mcp), d_MacroCmd_CONT_INIT);
			if(c != d_MacroCmd_RtnVal_NORMAL){
				uc_flag = *(unsigned char *)&c;
			}
			else {
				uc_flag = 0;
				Gs_ENA_prm.s_MacroCmd.uc_req			= TRUE;
			}
			
			break;
		
		// マクロコマンド実行の強制停止
		case d_Lcl_ENA_CMD_MacroFORCESTOP:
			Gs_ENA_prm.s_MacroCmd.uc_cmdenaflg	= FALSE;	// マクロコマンド実行要求受付 enable フラグをおろす
			Gs_ENA_prm.s_MacroCmd.uc_req		= FALSE;	// マクロコマンド実行要求フラグをおろす
		
			c = (char)app_macrocmd_cont(Gd_N_ENA, &(Gs_ENA_prm.s_MacroCmd.s_mcp), d_MacroCmd_CONT_INIT);
			if(c != d_MacroCmd_RtnVal_NORMAL){
				uc_flag = *(unsigned char *)&c;
			}
			else {
				uc_flag = 0;
			}

			break;
		
		// ミッションパケット中に HK を出す設定
		case d_Lcl_ENA_CMD_PRIO_HK_SET:
			if(i_Size < 1){ break; }

			uc = (0x0f & uc_Data[0]);
			if(uc == 0){									// パケット出力しない
				Gs_ENA_prm.s_oHK.ui_outinterval			= 0;
				Gs_ENA_prm.s_oHK.uc_outinterval_encoded	= 0;
				Gs_ENA_prm.s_oHK.ui_outinterval_ctr		= 0;
				Gs_ENA_prm.s_oHK.uc_clearctr_req		= FALSE;
			}
			else {
				Gs_ENA_prm.s_oHK.ui_outinterval = d_Lcl_ENA_MISSION_PCKT_OUTHK_INTERVALBASE;
				for(i = 2; i <= uc; i++){
					Gs_ENA_prm.s_oHK.ui_outinterval *= 2;
				}
			
//				Gs_ENA_prm.s_oHK.ui_outinterval_ctr 	= Gs_ENA_prm.s_oHK.ui_outinterval;
				Gs_ENA_prm.s_oHK.uc_outinterval_encoded	= uc;
				Gs_ENA_prm.s_oHK.uc_clearctr_req		= TRUE;
			}
		
			uc_flag = 0;
		
			break;

		// パラメータ初期化
		case d_Lcl_ENA_CMD_INITPARAM:
			if(i_Size < 1){ break; }

			uc = FALSE;
			if(uc_Data[0]){ uc = TRUE; }
		
			uc_flag = app01_InitVar_ENA_2(uc);

			break;
		
		
		// IFE へのテーブル書き込み (SV, auto discri)
		// テーブル書き込みには複数個のコマンドを IFE に送る必要がある。
		// 処理中に他の処理 (マクロコマンドなど) によって IFE にコマンド送信をしないこと。
		case d_Lcl_ENA_CMD_TBL_WRITE_SENSOR:
			if(i_Size < 1){ break; }
			Gs_ENA_prm.s_tblws.uc_wrt_target0  = uc_Data[0];
			Gs_ENA_prm.s_tblws.uc_wrt_req      = TRUE;
			Gs_ENA_prm.s_tblws.uc_wrtcount_rem = 0;
			
			uc_flag = 0;
			
			break;

		// フラグクリア
		case d_Lcl_ENA_CMD_FLG_CLEAR:
			if(i_Size < 1){ break; }
			
			if(0x01 & uc_Data[0]){
				Gs_ENA_prm.s_tblws.uc_endsts		= FALSE;	// テーブルライト (to IFE) ステータス
				uc_flag = 0;
			}
			
			if(0x02 & uc_Data[0]){
				Gs_ENA_prm.uc_reqUserreqcmd			= FALSE;	// ユーザーリクエストコマンドは送信していない
				Gs_ENA_prm.uc_reqUserreqcmd_reason	= FALSE;	// ユーザーリクエストコマンドの送信理由
				uc_flag = 0;
			}
			
			break;
			
		// マクロコマンド実行要求受付 enable / disable
		case d_Lcl_ENA_CMD_MACRO_ENA:
			if(i_Size < 1){ break; }
			
			if(0x01 & uc_Data[0]){
				Gs_ENA_prm.s_MacroCmd.uc_cmdenaflg = TRUE;
			}
			else {
				Gs_ENA_prm.s_MacroCmd.uc_cmdenaflg = FALSE;
			}
			
			uc_flag = 0;
			
			break;
		
		
		// エネルギーテーブル (SV RAM) の選択
		case d_Lcl_ENA_CMD_ENGY_TBL_SEL:
			if(i_Size < 1){ break; }
			
			uc = (0x07 & uc_Data[0]);					// SV RAM は 8種類
			uc_buf[0] = d_Lcl_ENA_SensorCMD_SelSVTbl;
			uc_buf[1] = ( (uc << 4) | uc);
			uc_buf[2] = ( (uc << 4) | uc);

//			ここでは Gs_ENA_prm.uc_SVRAMid をセットしない。HK で読んだ時にセットする。
//			センサーに直接コマンドを打つ場合があるので。
//			Gs_ENA_prm.uc_SVRAMid = uc;
			
			uc_flag = app_PiCmd(Gd_N_ENA, uc_buf, 3);
			
			// クリア要求 (スピンパルス待ち) (TODO: 確認要) app04 実行中に app01 が割り込むことはある??
			Gs_ENA_prm.uc_waitSlotID0 = TRUE;
		
			uc_flag = 0;
	
			break;
		
		
		// データ処理モードの設定
		case d_Lcl_ENA_CMD_PROCESS_MODE_SET:
			if(i_Size < 19){ break; }
			if(uc_Data[0] >= d_Lcl_ENA_MODENUM) { break; }
			
			
			uc_flg2 = TRUE;		// 未定義コマンドかどうかを判定するために使うフラグ
			uc_flg3 = TRUE;		// IFE へモード変更コマンドを送信するかどうかの判定に使うフラグ
			uc_flg4 = FALSE;	// SV table ID の変更要求をするかどうかを判定するために使うフラグ
			
			// トリガ判定データのクリア要求値設定 (ACCUMMASS, ACCUMCNT, ACCUMTOF モード以外の場合のセット値)
			Gs_ENA_prm.uc_trg_ena0 					= FALSE;
			Gs_ENA_prm.uc_trg_acqmode0 				= d_Lcl_ENA_TRG_REL;
			Gs_ENA_prm.uc_trg_prenum0				= 0; 
			Gs_ENA_prm.uc_trg_postnum0				= 0; 
			Gs_ENA_prm.uc_trg_precnt00				= 0; 
			Gs_ENA_prm.uc_trg_precnt01				= 0; 
			Gs_ENA_prm.uc_trg_postcnt00				= 0; 
			Gs_ENA_prm.uc_trg_postcnt01				= 0; 

			uc_lenph   = (0x3f & uc_Data[12]);
			uc_startph = (0x1f & uc_Data[13]);
			if(uc_lenph == 0){ uc_lenph = 32; }
		
			uc_id = (0x0f & uc_Data[0]);
			switch(uc_id){
				case d_Lcl_ENA_MODE_IDLE:
				
					uc_flg3 = FALSE;		// IFE にモード変更コマンドを送信しない
					
// TODO: mode パラメータのセットまたはクリア

					break;
				
				case d_Lcl_ENA_MODE_DUMP:
				
					uc_flg3 = FALSE;		// IFE にモード変更コマンドを送信しない
					
					// パラメータクリア
					puc = (unsigned char *)&Gs_ENA_prm.s_dmp;
					for(i = 0; i < sizeof(struct _s_ENA_DumpMode); i++){
						*puc++ = 0;
					}
					break;

				case d_Lcl_ENA_MODE_ACCUMMASS:
				case d_Lcl_ENA_MODE_ACCUMCNT:
				case d_Lcl_ENA_MODE_ACCUMTOF:
				
					// トリガ判定データのクリア要求値設定
					Gs_ENA_prm.uc_trg_ena0 					= (uc_Data[8] & 0x01);
					Gs_ENA_prm.uc_trg_acqmode0 				= ((uc_Data[8] >> 4) & 0x03);
					Gs_ENA_prm.uc_trg_prenum0				= ((uc_Data[14] >> 4) & 0x0f);
					Gs_ENA_prm.uc_trg_postnum0				= (uc_Data[14] & 0x0f); 
					Gs_ENA_prm.uc_trg_precnt00				= uc_Data[15];
					Gs_ENA_prm.uc_trg_precnt01				= (uc_Data[16] & 0x1f); 
					Gs_ENA_prm.uc_trg_postcnt00				= uc_Data[17];
					Gs_ENA_prm.uc_trg_postcnt01				= (uc_Data[18] & 0x1f); 
					// Gs_ENA_prm.uc_trg_prenum0 + Gs_ENA_prm.uc_trg_postnum0 + 1 で +1 するのは トリガ前データと
					//  トリガ後データの間に 1データ入れるため。
					if(Gs_ENA_prm.uc_trg_prenum0 + Gs_ENA_prm.uc_trg_postnum0 + 1> d_Lcl_ENA_TRGDATA_NUM){
						uc_flg2 = FALSE;
						break;
					}
				
				
					uc_flg4 = TRUE;			// SV table ID 変更要求を行う。
				
					ucch = (0x0f & (uc_Data[1] >> 4));
					ucen = (0x0f & uc_Data[1]);
					ucph = (0x3f & uc_Data[2]);
					ucma = uc_Data[3];

					if( ! (uc_lenph == 1 || uc_lenph == 2 || uc_lenph == 4 || uc_lenph == 8 || uc_lenph == 16 || uc_lenph == 32) ){
						uc_flg2 = FALSE;
						break;
					}

					if(uc_id == d_Lcl_ENA_MODE_ACCUMMASS){
						uc_buf[1] = d_Lcl_ENA_SENSORMODE_COINCI;	// コインシデンスモード
						
						// ch (START SECTOR) は到来方向弁別に用いる。
						//   ch 信号が存在しない場合を含めるため、チャンネル数 2 と 8 のモードがある。
						//   ucch = 1 と 7 のモードは ch 無信号の TOF イベントを無視する。
						if( !(ucch == 1 || ucch == 2 || ucch == 7 || ucch == 8) ){
							uc_flg2 = FALSE;
							break;
						}
						if( !(ucen == 1 || ucen == 2 || ucen == 4 || ucen == 8) ){
							uc_flg2 = FALSE;
							break;
						}
						if( !(ucph == 1 || ucph == 2 || ucph == 4 || ucph == 8 || ucph == 16 || ucph == 32) ){
							uc_flg2 = FALSE;
							break;
						}
						if( !(ucma == 1 || ucma == 2 || ucma == 4 || ucma == 8 || ucma == 16 || ucma == 32
																			|| ucma == 64 || ucma == 128) ){
							uc_flg2 = FALSE;
							break;
						}
						
						// energy bin * phase bin は最大 128 (1スピン中には 128スロットしかない)
						if(ucen * ucph > d_Lcl_ENA_SLOT_NUM){
							uc_flg2 = FALSE;
							break;
						}
						
						// bin 数は最大 8192
						if(ucph * ucen * ucma * ucch > d_Lcl_ENA_MAXBINNUM_ACCUMMASS){
							uc_flg2 = FALSE;
							break;
						}
						if(ucph != 32){
							if(uc_lenph == 1 || (uc_startph % 2) == 1){	// この場合、エネルギー掃引の途中からデータ処理がスタートする。
																		//  このため、uc_numP0 が 32である必要がある。
								uc_flg2 = FALSE;
								break;
							}
						}
					
						// uc_numP0 で規定される 1 bin あたりの phase 数の整数倍に uc_lenph がなっていない場合
						if(0 != uc_lenph % (32 / ucph)){
							uc_flg2 = FALSE;
							break;
						}
						
						Gs_ENA_prm.uc_lenP   = uc_lenph;
						Gs_ENA_prm.uc_startP = uc_startph;
						Gs_ENA_prm.uc_numP   = ucph * uc_lenph / 32;
						
						Gs_ENA_prm.uc_numE   = ucen;
						Gs_ENA_prm.uc_numP0  = ucph;
						Gs_ENA_prm.uc_numC   = ucch;
						Gs_ENA_prm.uc_numM   = ucma;
						Gs_ENA_prm.us_numTOF = 1;
					}
					else if(uc_id == d_Lcl_ENA_MODE_ACCUMCNT){
						uc_buf[1] = d_Lcl_ENA_SENSORMODE_COUNT;		// カウンタモード

						if( !(ucen == 1 || ucen == 2 || ucen == 4 || ucen == 8) ){
							uc_flg2 = FALSE;
							break;
						}
						if( !(ucph == 1 || ucph == 2 || ucph == 4 || ucph == 8 || ucph == 16 || ucph == 32) ){
							uc_flg2 = FALSE;
							break;
						}
						// energy bin * phase bin は最大 128 (1スピン中には 128スロットしかない)
						if(ucen * ucph > d_Lcl_ENA_SLOT_NUM){
							uc_flg2 = FALSE;
							break;
						}

						
						if(ucph != 32){
							if(uc_lenph == 1 || (uc_startph % 2) == 1){	// この場合、エネルギー掃引の途中からデータ処理がスタートする。
																		//  このため、uc_numP0 が 32である必要がある。
								uc_flg2 = FALSE;
								break;
							}
						}
						
						// uc_numP0 で規定される 1 bin あたりの phase 数の整数倍に uc_lenph がなっていない場合
						if(0 != uc_lenph % (32 / ucph)){
							uc_flg2 = FALSE;
							break;
						}
#ifdef	d_ENA_LOCAL_EMU
	fprintf(stderr, "CNTMODE ok\n");
#endif
						
						Gs_ENA_prm.uc_lenP   = uc_lenph;
						Gs_ENA_prm.uc_startP = uc_startph;
						Gs_ENA_prm.uc_numP   = ucph * uc_lenph / 32;

						Gs_ENA_prm.uc_numE   = ucen;
						Gs_ENA_prm.uc_numP0  = ucph;
						Gs_ENA_prm.uc_numC   = 1;
						Gs_ENA_prm.uc_numM   = 1;
						Gs_ENA_prm.us_numTOF = 1;

					}
					else if(uc_id == d_Lcl_ENA_MODE_ACCUMTOF){
						uc_buf[1] = d_Lcl_ENA_SENSORMODE_COINCI;	// コインシデンスモード
						
						if( !(ucen == 1 || ucen == 2 || ucen == 4 || ucen == 8) ){
							uc_flg2 = FALSE;
							break;
						}

						//   TOF accumulation mode では、phase bin は 1。ただし、コマンドに 32 を書いた場合には
						//   energy step が 4毎の繰り返しになっているとして扱う (energy step0 = step4, step1 = step5, ... step3 = step7)。
						//  ---> SV RAM 選択に注意!!
						if( !(ucph == 1 || ucph == 32) ){
							uc_flg2 = FALSE;
							break;
						}
						
						// energy bin * phase bin は最大 128 (1スピン中には 128スロットしかない)
						if(ucen * ucph > d_Lcl_ENA_SLOT_NUM){
							uc_flg2 = FALSE;
							break;
						}
						
						if(ucph != 32){
							if(uc_lenph == 1 || (uc_startph % 2) == 1){	// この場合、エネルギー掃引の途中からデータ処理がスタートする。
																		//  このため、uc_numP0 が 32である必要がある。
								uc_flg2 = FALSE;
								break;
							}
						}
							
						Gs_ENA_prm.uc_lenP   = uc_lenph;
						Gs_ENA_prm.uc_startP = uc_startph;
						Gs_ENA_prm.uc_numP   = 1;
						
						Gs_ENA_prm.uc_numE   = ucen;
						Gs_ENA_prm.uc_numP0  = ucph;
						Gs_ENA_prm.uc_numC   = 1;
						Gs_ENA_prm.uc_numM   = 1;
						Gs_ENA_prm.us_numTOF = 0x400;
					}
					
					// uc_num?? からデータ処理の際に必要なビットシフト量 (uc_shift?) を計算し、セットする。
					app01_ENA_SetProcessParam1();

					// データを重ね合わせる回数の設定
					Gs_ENA_prm.uc_num_add_interval_Spin_encoded	= (uc_Data[9] >> 4);
					Gs_ENA_prm.us_numaddSpin					= 1;

					for(uc = 0; uc < Gs_ENA_prm.uc_num_add_interval_Spin_encoded; uc++){
						Gs_ENA_prm.us_numaddSpin *= 2;
					}

					break;
					
				case d_Lcl_ENA_MODE_NONPROCESS:					// non-process モード
				case d_Lcl_ENA_MODE_IFE_ENGINEERING:			// engineering モード
				case d_Lcl_ENA_MODE_IFE_TABLEREAD:				// テーブルリードモード
				
//					// このモードでは uc_lenph = 1 (slotID 4つ分) には対応しない。
//					if( ! (uc_lenph == 2 || uc_lenph == 4 || uc_lenph == 8 || uc_lenph == 16 || uc_lenph == 32) ){
//						uc_flg2 = FALSE;
//						break;
//					}
//					// uc_startph が奇数 (エネルギー掃引の途中からスタート) であってはいけない。
//					if( 1 == uc_startph % 2 ){
//						uc_flg2 = FALSE;
//						break;
//					}
			
					if(uc_id == d_Lcl_ENA_MODE_NONPROCESS){
						uc_flg3 = FALSE;						// IFE にモード変更コマンドを送信しない
					}
					else if(uc_id == d_Lcl_ENA_MODE_IFE_ENGINEERING){
						uc_buf[1] = (0x10 | d_Lcl_ENA_SENSORMODE_ENG);		// engineering モード
																			// event selection mask は設定しない
					}
					else if(uc_id == d_Lcl_ENA_MODE_IFE_TABLEREAD){
						uc_buf[1] = (0x10 | d_Lcl_ENA_SENSORMODE_SVREAD);	// テーブルリードモード
																			// event selection mask は設定しない
					}
					
					Gs_ENA_prm.uc_lenP   = uc_lenph;
					Gs_ENA_prm.uc_startP = uc_startph;

				// データ処理間隔の設定
					Gs_ENA_prm.uc_num_add_interval_Spin_encoded	= (uc_Data[9] >> 4);
					Gs_ENA_prm.s_npm.us_IntervalSpin			= 1;

					for(uc = 0; uc < Gs_ENA_prm.uc_num_add_interval_Spin_encoded; uc++){
						Gs_ENA_prm.s_npm.us_IntervalSpin *= 2;
					}
					
					Gs_ENA_prm.s_npm.uc_numProcessPckt_inSpin_encoded = (0x07 & uc_Data[9]);

					// 送信パケット数の設定
					Gs_ENA_prm.s_npm.us_numpckt_tgt  = 0x100 * uc_Data[10] + uc_Data[11];
					Gs_ENA_prm.s_npm.us_numpckt_sent = 0;

					break;
					
				default:
					uc_flg2 = FALSE;
					break;
			}

			if(uc_flg2 == FALSE){ break; } // 定義されていないモードをセットしようとした場合の対応
			
			// 必要な場合、IFE にモード変更コマンドを送信する
			//  uc_buf[1] はすでに設定されている
			if(uc_flg3 == TRUE){
				uc_buf[0] = d_Lcl_ENA_SensorCMD_ModeSet;
				uc_buf[2] = uc_Data[5];
				uc_buf[3] = uc_Data[6];
				uc_buf[4] = uc_Data[7];
				uc_buf[5] = 0x00;
				app_PiCmd(Gd_N_ENA, uc_buf, 6);		// コマンド送信の失敗時を考慮する必要はある??
			}
			
			// データ処理モード
			Gs_ENA_prm.uc_ProcessMode = (0x0f & uc_Data[0]);
			
			// クリア要求 (スピンパルス待ち) (TODO: 確認要) app04 実行中に app01 が割り込むことはある??
			Gs_ENA_prm.uc_waitSlotID0 = TRUE;
		
			// SV table 変更要求
			if(uc_flg4 == TRUE){
				Gs_ENA_prm.uc_svtbl_idtgt			= (0x07 & uc_Data[4]);
				Gs_ENA_prm.uc_svtnl_chg_waitcount	= 0;
				Gs_ENA_prm.uc_svtbl_chgreq			= TRUE;
			}
			
			// テレメ出力バッファのクリア
			Gs_ENA_prm.s_omt[d_Lcl_ENA_MISTLMOUTBUFID_MIS].uc_flg_bufempty = TRUE;
		
			// ミッション TLM 中への HK 出力のカウンタリセット
			Gs_ENA_prm.s_oHK.uc_clearctr_req		= TRUE;

			// MDP 内に残っている処理前のブロックデータのクリア要求
			Gs_ENA_prm.s_mdb.uc_clear_req			= TRUE;
		
			// トリガ判定データのクリア要求
			Gs_ENA_prm.uc_trg_clear_req				= TRUE;
		
			uc_flag = 0;

			break;
		
		case d_Lcl_ENA_CMD_HEALTH_CHECK_SET:
		
			break;
		
		
		// 圧縮モードセット
		case d_Lcl_ENA_CMD_CPRS_SET:
			if(i_Size < 1){ break; }
			
			Gs_ENA_prm.uc_CprsWayFlg = (0x03 & uc_Data[0]);
		
			if(Gs_ENA_prm.uc_CprsWayFlg == d_Lcl_ENA_CPRS_RICE){
				Guc_TLMm_cmp[Gd_N_ENA] = 3; // ユーザ圧縮 (システムによる圧縮なし)
			}
			else {
				Guc_TLMm_cmp[Gd_N_ENA] = 0; // システムによる圧縮処理なし
			}
		
			uc_flag = 0;

			break;
			
		case d_Lcl_ENA_CMD_NONCOINCI_REP:
		
			break;
			
		case d_Lcl_ENA_CMD_MASSFACTOR_SET:
			if(i_Size < 2) { break; }
			
			Gs_ENA_prm.us_MassFactor = 0x100 * uc_Data[0] + uc_Data[1];
			
			// クリア要求 (スピンパルス待ち) (TODO: 確認要) app04 実行中に app01 が割り込むことはある??
			Gs_ENA_prm.uc_waitSlotID0 = TRUE;
			
			uc_flag = 0;
			
			break;
		
		
		// テーブルダンプ (EEPROM, MDP RAM)
		case d_Lcl_ENA_CMD_DUMP_MDPTBL:
			if(i_Size < 6){ break; }
			
			// DUMP MODE であることが必要。
			if(Gs_ENA_prm.uc_ProcessMode != d_Lcl_ENA_MODE_DUMP){ break; }
			
			// TODO: 確認要。 app04 実行中に app01 が割り込むことはある??
			Gs_ENA_prm.s_dmp.us_dump_target_req		= 0x100 * uc_Data[0] + uc_Data[1];
			Gs_ENA_prm.s_dmp.us_size				= d_Lcl_ENA_DUMP_SETSIZEUNIT * uc_Data[2];
			Gs_ENA_prm.s_dmp.ui_address				= 0x1000000 * uc_Data[3] + 0x10000 * uc_Data[4]
														+ 0x100 * uc_Data[5] + uc_Data[6];

			Gs_ENA_prm.s_dmp.us_outsize_eachtarget	= 0; // 出力したサイズ (ターゲット毎)
			Gs_ENA_prm.s_dmp.us_dump_target			= Gs_ENA_prm.s_dmp.us_dump_target_req;
			
			uc_flag = 0;
			break;
		
		
		// manual discri 値を IFE に書き込む
		// テーブル書き込みには複数個のコマンドを IFE に送る必要がある。
		// 処理中に他の処理 (マクロコマンドなど) によって IFE にコマンド送信をしないこと。
		case d_Lcl_ENA_CMD_DISCRI_TBL_WRITE_SENSOR:
		
			if(i_Size < 19){ break; }
			
			Gs_ENA_prm.s_tblws.uc_wrt_target0_mdis	= TRUE;
			Gs_ENA_prm.s_tblws.uc_wrt_req_mdis		= TRUE;
			Gs_ENA_prm.s_tblws.uc_wrtcount_rem_mdis	= 0;
			
			if( !(0x80 & uc_Data[0]) ){		// data from command
				puc = &Gs_ENA_prm.s_tblws.uc_mdiscri_data[0];
				*puc++ = (0x03 & (uc_Data[3] >> 6));						// START RING 1
				*puc++ = (0x03 & (uc_Data[3] >> 4));						// START RING 2
				*puc++ = (0x03 & (uc_Data[3] >> 2));						// START RING 3
				*puc++ = (0x03 & uc_Data[3]);								// START RING 4
				for(i = 0; i < d_Lcl_ENA_DISCRITBL_DATANUM_STORE - 1; i++){	// START SECTORS and STOP SECTORS
					*puc++ = uc_Data[4 + i];
				}
			}
			else{
				uc_id = (0x1f & uc_Data[0]);
				if(0x40 & uc_Data[0]){		// data from MDP RAM
					puc = &Gs_ENA_prm.s_tblws.uc_mdiscri_data[3];
					for(i = 0; i < d_Lcl_ENA_DISCRITBL_DATANUM_STORE; i++){
						*puc++ = Guc_ENA_DiscriTbl_RAM[uc_id][i];
					}
				}
				else {						// data from EEPROM
											// EEPROM には auto discri と同じフォーマットで書く。
											//   このため、各テーブルのサイズは d_Lcl_ENA_AUTODISCRITBL_DATANUM_STORE となる。
											//   (d_Lcl_ENA_DISCRITBL_DATANUM_STORE ではない)。
											//   また、同様の理由により、各テーブル最初の 2バイトは無視される。
					app_readROM(Gd_ENA_RomAdr + d_Lcl_ENA_DiscriTbl_EEPROM_adr
															 + uc_id * d_Lcl_ENA_AUTODISCRITBL_DATANUM_STORE + 2,
											d_Lcl_ENA_DISCRITBL_DATANUM_STORE,
											&Gs_ENA_prm.s_tblws.uc_mdiscri_data[3]);
				}
				// START RING
				Gs_ENA_prm.s_tblws.uc_mdiscri_data[0] = (0x03 & (Gs_ENA_prm.s_tblws.uc_mdiscri_data[3] >> 6));
				Gs_ENA_prm.s_tblws.uc_mdiscri_data[1] = (0x03 & (Gs_ENA_prm.s_tblws.uc_mdiscri_data[3] >> 4));
				Gs_ENA_prm.s_tblws.uc_mdiscri_data[2] = (0x03 & (Gs_ENA_prm.s_tblws.uc_mdiscri_data[3] >> 2));
				Gs_ENA_prm.s_tblws.uc_mdiscri_data[3] = (0x03 & Gs_ENA_prm.s_tblws.uc_mdiscri_data[3]);
			}
			
			uc_flag = 0;
			
			break;

		// manual discri, auto discri table の MDP RAM への書き込み
		case d_Lcl_ENA_CMD_DISCRI_TBL_WRITE_MDP:

			if(i_Size < 19){ break; }
			
			uc_id = (0x1f & uc_Data[0]);
			
			// manual discri table
			if(0x40 & uc_Data[0]){
				for(i = 0; i < d_Lcl_ENA_DISCRITBL_DATANUM_STORE; i++){
					Guc_ENA_DiscriTbl_RAM[uc_id][i] = uc_Data[3 + i];
				}
			}
			// auto discri table
			else {
				uc = (0x80 & uc_Data[0]) ? 1 : 0;		// table ID
				
				puc = &Guc_ENA_AutoDiscriTbl_RAM[uc][uc_id][0];

				*puc++ = (0x0f & uc_Data[1]);			// temperature 上位4ビット				
				for(i = 1; i < d_Lcl_ENA_AUTODISCRITBL_DATANUM_STORE; i++){
					*puc++ = uc_Data[1 + i];
				}
			}
			
			uc_flag = 0;
			
			break;
			
		// マクロコマンドテーブルライト 
		case d_Lcl_ENA_CMD_MACRO_TBL_WRITE_MDP:
			if(i_Size < 3){ break; }
				
			// 最大 macro command table数は 32
			// このうち macroID = 0 - (d_Lcl_ENA_MACROCMDTblNUM_ROM - 1) は EEPROM に格納されている。
			// macroID = d_Lcl_ENA_MACROCMDTblNUM_ROM -- 31 が RAM 格納可能分
			uc_id = (0x1f & uc_Data[0]);
			if(uc_id < d_Lcl_ENA_MACROCMDTblNUM_ROM){ break; }
			if(uc_id >= d_Lcl_ENA_MACROCMDTblNUM_ROM + d_Lcl_ENA_MACROCMDTblNUM_RAM){ break; }

			us_adr_s = uc_Data[1] * d_Lcl_ENA_MACRO_TBL_WRITE_UNITLEN;

			if(us_adr_s + i_Size - 2 > d_Lcl_ENA_MACROCMDTbl_size){ break; }
					
			puc = &Guc_ENA_MacroCmdTbl_RAM[uc_id - d_Lcl_ENA_MACROCMDTblNUM_ROM][us_adr_s];
			for(i = 2; i < i_Size; i++){ // テーブル内容は uc_Data[3] から始まる
				*puc++ = uc_Data[i];
			}
			
			uc_flag = 0;
			break;
				
		// EEPROM から MDP RAM への lookup テーブル読み込み
		case d_Lcl_ENA_CMD_LOOKUP_TBL_WRITE_MDP:
				
			app01_ENA_TblReadfromEEPROM();
				
			uc_flag = 0;
			break;

		// 観測カウントの LinLog 処理時の depth とオフセットの設定
		case d_Lcl_ENA_CMD_LINLOG_DEPTH_OFFSET_SET:
			if(i_Size < 5){ break; }
		
			uc_flg2 = TRUE;
			switch(0x03 & uc_Data[0]){
				case 0:
					Gs_ENA_prm.uc_CntDepth = d_Lcl_ENA_CntDepth32;
					break;
				case 1:
					Gs_ENA_prm.uc_CntDepth = d_Lcl_ENA_CntDepth16;
					break;
				case 2:
					Gs_ENA_prm.uc_CntDepth = d_Lcl_ENA_CntDepth12;
					break;
				default:
					uc_flg2 = FALSE;
					break;
			}
			if(uc_flg2 == FALSE){
				break;
			}
		
			Gs_ENA_prm.ui_CntOffset = 0x1000000 * uc_Data[1] + 0x10000 * uc_Data[2]
											+ 0x100 * uc_Data[3] + uc_Data[4];
		
			// クリア要求 (スピンパルス待ち) (TODO: 確認要) app04 実行中に app01 が割り込むことはある??
			Gs_ENA_prm.uc_waitSlotID0 = TRUE;
		
			uc_flag = 0;
		
			break;
		
		// MDP 内に残っている処理前のブロックデータをクリアする
		case d_Lcl_ENA_CMD_BLOCK_CLR:
					
			Gs_ENA_prm.s_mdb.uc_clear_req = TRUE;
				
			uc_flag = 0;
				
			break;

		
		// 自動ディスクリ制御を dis にすると manual discri 値を IFE に書き込む。
		// テーブル書き込みには複数個のコマンドを IFE に送る必要がある。
		// ***********************
		// 処理中に他の処理 (マクロコマンドなど) によって IFE にコマンド送信をしないこと。
		// ***********************
		// コマンド d_Lcl_ENA_CMD_DISCRI_TBL_WRITE_SENSOR と同様の動作を行う。
		case d_Lcl_ENA_CMD_MDPAUTODISCRI_ENA:

#ifdef	d_ENA_AUTODISCRI_MDP		// 120704 KA
			if(i_Size < 1){ break; }

			if(uc_Data[0] != FALSE){
				// これまで manual discri であった場合、auto discri をスタートする前にディスクリ値を保存する。
				if(Gs_ENA_prm.s_adis_mdp.uc_autoena == FALSE){
					memcpy(&Gs_ENA_prm.s_adis_mdp.uc_discri_manu[0], &Gs_ENA_prm.s_sHK.uc_discri_data[0],
										d_Lcl_ENA_DISCRITBL_DATANUM);
				}
				Gs_ENA_prm.s_adis_mdp.uc_autoena     = TRUE;
				Gs_ENA_prm.s_adis_mdp.us_temp_addnum = 0;
				Gs_ENA_prm.s_adis_mdp.ui_addtemp     = 0;
				Gs_ENA_prm.s_adis_mdp.uc_wrt_target  = FALSE;  // ディスクリ変更中の場合、中断する
			}
			else {
				Gs_ENA_prm.s_adis_mdp.uc_autoena      = FALSE;
				Gs_ENA_prm.s_adis_mdp.uc_autoena_past = FALSE;
				Gs_ENA_prm.s_adis_mdp.uc_check_req    = FALSE;
				Gs_ENA_prm.s_adis_mdp.uc_chg_req      = FALSE;
				Gs_ENA_prm.s_adis_mdp.uc_wrt_target   = FALSE;  // ディスクリ変更中の場合、中断する
				
				// manual discri 値を IFE に書き込む
				// テーブル書き込みには複数個のコマンドを IFE に送る必要がある。
				// 処理中に他の処理 (マクロコマンドなど) によって IFE にコマンド送信をしないこと。
				// コマンド d_Lcl_ENA_CMD_DISCRI_TBL_WRITE_SENSOR と同様の動作を行う。
				Gs_ENA_prm.s_tblws.uc_wrt_target0_mdis	= TRUE;
				Gs_ENA_prm.s_tblws.uc_wrt_req_mdis		= TRUE;
				Gs_ENA_prm.s_tblws.uc_wrtcount_rem_mdis	= 0;
				memcpy(&Gs_ENA_prm.s_tblws.uc_mdiscri_data[0], &Gs_ENA_prm.s_adis_mdp.uc_discri_manu[0],
										d_Lcl_ENA_DISCRITBL_DATANUM);
			
			}
		
			uc_flag = 0;
#endif
			break;
		
		case d_Lcl_ENA_CMD_MDPAUTODISCRI_TBL_SET:

#ifdef	d_ENA_AUTODISCRI_MDP		// 120704 KA
			if(i_Size < 1){ break; }
		
			Gs_ENA_prm.s_adis_mdp.uc_tblid = (0x01 & uc_Data[0]);
		
			if(Gs_ENA_prm.s_adis_mdp.uc_autoena == TRUE){
				Gs_ENA_prm.s_adis_mdp.uc_tblchg_recv = TRUE;
				Gs_ENA_prm.s_adis_mdp.uc_wrt_target  = FALSE;  // ディスクリ変更中の場合、中断する
			}
			uc_flag = 0;
			
#endif
			break;
		
		case d_Lcl_ENA_CMD_CNT1_SET:

			break;
			
		case d_Lcl_ENA_CMD_CNT2_SET:
		
			break;
		
		// NOP
		case d_Lcl_ENA_CMD_NOP:
		
			uc_flag = 0;
			break;
		
		// (試験用コマンド) MDP へのユーザーリクエストコマンド送信
		case d_Lcl_ENA_CMD_CHK_DMC_REQCMD:
			if(i_Size < 2) { break; }
		
			if(uc_Data[0] != d_Lcl_ENA_CHK_DMC_REQCMD_CONST1){ break; }
			if(uc_Data[1] != d_Lcl_ENA_CHK_DMC_REQCMD_CONST2){ break; }
				
			Gs_ENA_prm.uc_reqUserreqcmd 		= TRUE;
			Gs_ENA_prm.uc_reqUserreqcmd_reason  = d_Lcl_ENA_ReqUserreqcmd_TestCMD;

			app_DmcRequestCmd(0x0e);	// PCD-ENA-PSU-OFF
	
			uc_flag = 0;
			break;
				
		default:
			break;

//		default:
//			uc_flag = 0xFF;
//			break;	// *** Error: CMD not found ***
	}
	
	
	// 外部からのコマンドの場合のみ処理する
	if(uc_extcmd){
		// コマンドアンサ
		Gs_ENA_prm.s_saveparam.uc_cmdanswer[0] = (0xff & (ui_Cntl >> 8));
		Gs_ENA_prm.s_saveparam.uc_cmdanswer[1] = (0xff & ui_Cntl);
		for(i = 0; i < d_Lcl_ENA_CMD_ANSWER_SIZE - 2; i++){
			if(i < i_Size){
				Gs_ENA_prm.s_saveparam.uc_cmdanswer[i + 2] = uc_Data[i];
			}
			else {
				Gs_ENA_prm.s_saveparam.uc_cmdanswer[i + 2] = 0;
			}
		}
	
		// コマンドカウンタのインクリメント
		if(uc_flag != 0){
			Gs_ENA_prm.s_saveparam.uc_cmderrctr++;
		}
		Gs_ENA_prm.s_saveparam.uc_cmdctr++;
	}

#ifdef	d_ENA_LOCAL_EMU
	if_emu_mdpcmdout(ui_Cntl, uc_Data, i_Size, uc_extcmd, uc_flag);
#endif


	return( uc_flag );
}



char app01_ENA_SetProcessParam1(void)
// データ処理に必要なパラメータを計算する
{
	unsigned char uc, uc2;
	int i;
	unsigned int *pui;
	struct _s_ENA_param *psp;

	psp = &Gs_ENA_prm;

	psp->uc_waitSlotID0 = TRUE;		// slotID = 0 を待たせるフラグ
	psp->uc_datatopflg	= FALSE;

	// numE * numP は 128 以下でなくてはならない
	if(psp->uc_numE == 8 && psp->uc_numP0 == 32){
		psp->uc_numP0 = 16;
		if(psp->uc_numP == 32){ psp->uc_numP = 16; }
	}
	
	
	// セットされた分解能に応じたビットシフト量の設定
#ifdef	d_ENA_ATTEMPT_TO_SMALLSIZE
	uc = psp->uc_numE;
	if(uc == 8)		{ uc2 = 0; }
	else if(uc == 4){ uc2 = 1; }
	else if(uc == 2){ uc2 = 2; }
	else			{ uc2 = 3; }
	psp->uc_shiftE = uc2;
#else
	psp->uc_shiftE = 3;
	switch(psp->uc_numE){
		case 8:
			psp->uc_shiftE--;
		case 4:
			psp->uc_shiftE--;
		case 2:
			psp->uc_shiftE--;
		case 1:
			break;
	}
#endif	
#ifdef	d_ENA_ATTEMPT_TO_SMALLSIZE
	uc = psp->uc_numP0;
	if(uc == 32)		{ uc2 = 0; }
	else if(uc == 16)	{ uc2 = 1; }
	else if(uc == 8)	{ uc2 = 2; }
	else if(uc == 4)	{ uc2 = 3; }
	else if(uc == 2)	{ uc2 = 4; }
	else				{ uc2 = 5; }
	psp->uc_shiftP = uc2;
#else
	psp->uc_shiftP = 5;
	switch(psp->uc_numP0){
		case 32:
			psp->uc_shiftP--;
		case 16:
			psp->uc_shiftP--;
		case 8:
			psp->uc_shiftP--;
		case 4:
			psp->uc_shiftP--;
		case 2:
			psp->uc_shiftP--;
		case 1:
			break;
	}
#endif	
	
	// numC = 1 or 7 の場合は ch (START SECTOR) に無信号の TOF イベントは無視する。
#ifdef	d_ENA_ATTEMPT_TO_SMALLSIZE
	psp->uc_shiftC = 3;
	if(psp->uc_numC == 8 || psp->uc_numC == 7)		{ psp->uc_shiftC = 0; }
#else
	switch(psp->uc_numC){
		case 8:
		case 7:
			psp->uc_shiftC = 0;
			break;
		case 2:
		case 1:
		default:
			psp->uc_shiftC = 3;
			break;
	}
#endif
	
#ifdef	d_ENA_ATTEMPT_TO_SMALLSIZE
	uc = psp->uc_numM;
	if(uc == 128)		{ uc2 = 0; }
	else if(uc == 64)	{ uc2 = 1; }
	else if(uc == 32)	{ uc2 = 2; }
	else if(uc == 16)	{ uc2 = 3; }
	else if(uc == 8)	{ uc2 = 4; }
	else if(uc == 4)	{ uc2 = 5; }
	else if(uc == 2)	{ uc2 = 6; }
	else				{ uc2 = 7; }
	psp->uc_shiftM = uc2;
#else
	psp->uc_shiftM = 7;
	switch(psp->uc_numM){
		case 128:
			psp->uc_shiftM--;
		case 64:
			psp->uc_shiftM--;
		case 32:
			psp->uc_shiftM--;
		case 16:
			psp->uc_shiftM--;
		case 8:
			psp->uc_shiftM--;
		case 4:
			psp->uc_shiftM--;
		case 2:
			psp->uc_shiftM--;
		case 1:
			break;
	}
#endif
	
	psp->uc_shiftTOF   = (psp->us_numTOF == 0x400) ? 0 : 10;

	
	// バッファクリア
	pui = Gui_ENA_AccumMat;
	for(i = 0; i < d_Lcl_ENA_ACCUMTBL_SIZE / 4; i++){
		*pui++ = 0;
	}
	
	return TRUE;
}


char app01_ENA_MacroCmdTblSet(unsigned char *puc_dest, unsigned char uc_id)
//
// マクロコマンドデータの読み込み (EEPROM または MDP RAM から)
{
#ifndef	d_ENA_ATTEMPT_TO_SMALLSIZE2		// 120416
	unsigned char *puc;
	int i;
#endif
	
	if(uc_id < d_Lcl_ENA_MACROCMDTblNUM_ROM){			// EEPROM からのマクロコマンドデータ読み込み
		app_readROM(Gd_ENA_RomAdr + d_Lcl_ENA_MacroCmdTbl_EEPROM_adr + uc_id * d_Lcl_ENA_MACROCMDTbl_size,
															d_Lcl_ENA_MACROCMDTbl_size, puc_dest);
	}
	else if(uc_id < d_Lcl_ENA_MACROCMDTblNUM_ROM + d_Lcl_ENA_MACROCMDTblNUM_RAM){	// MDP RAM からのマクロコマンドデータ読み込み
#ifdef	d_ENA_ATTEMPT_TO_SMALLSIZE2		// 120416
		memcpy(puc_dest, &Guc_ENA_MacroCmdTbl_RAM[uc_id - d_Lcl_ENA_MACROCMDTblNUM_ROM][0], d_Lcl_ENA_MACROCMDTbl_size);
#else
		puc = puc_dest;
		for(i = 0; i < d_Lcl_ENA_MACROCMDTbl_size; i++){
			*puc++ = Guc_ENA_MacroCmdTbl_RAM[uc_id - d_Lcl_ENA_MACROCMDTblNUM_ROM][i];
		}
#endif
	}
	else {
		return FALSE;
	}
	
	Gs_ENA_prm.uc_macrocmdtableID = uc_id;
	
	return TRUE;
}



char app01_ENA_TblReadfromEEPROM(void)
//
// EEPROM からのテーブルデータ読み込み
{
	unsigned char *puc;
	unsigned short *pus, *pus2;
	int i, j;
	
	// SVM table
	app_readROM(Gd_ENA_RomAdr + d_Lcl_ENA_SVMTbl_EEPROM_adr, d_Lcl_ENA_SVMTbl_EEPROM_size, &Guc_ENA_SVM[0][0]);
	puc = &Guc_ENA_SVM[0][0];
	for(i = 0; i < d_Lcl_ENA_SVMTbl_EEPROM_size; i++){
		*puc++ &= 0x0f;
	}
	
	// SVE table
	app_readROM(Gd_ENA_RomAdr + d_Lcl_ENA_SVETbl_EEPROM_adr, d_Lcl_ENA_SVETbl_EEPROM_size, 
																(unsigned char *)&Gus_ENA_SVE[0]);
	pus = &Gus_ENA_SVE[0];
	for(i = 0; i < d_Lcl_ENA_SVETbl_EEPROM_size / 2; i++){
#ifdef d_ENA_LITTLE_ENDIAN
		*pus++ &= 0xff03;
#else
		*pus++ &= 0x03ff;
#endif
	}

	// LT table
	app_readROM(Gd_ENA_RomAdr + d_Lcl_ENA_LTTbl_EEPROM_adr, d_Lcl_ENA_LTTbl_EEPROM_size,
																(unsigned char *)&Gus_ENA_LT[0][0][0][0]);
	pus = &Gus_ENA_LT[0][0][0][0];
	for(i = 0; i < d_Lcl_ENA_LTTbl_EEPROM_size / 2; i++){
#ifdef d_ENA_LITTLE_ENDIAN
		*pus++ &= 0xff0f;
#else
		*pus++ &= 0x0fff;
#endif
	}
	
	// EEPROM 上のテーブルには E-index に対応する要素が入っていないため、E-index 分を拡張する。
	pus   = &Gus_ENA_LT[0][0][0][0];
	pus  += (d_Lcl_ENA_LTTbl_EEPROM_size / 2) - 1;
	pus2  = &Gus_ENA_LT[0][0][0][0];
	pus2 += (d_Lcl_ENA_LTTbl_EEPROM_size / 2) * d_Lcl_ENA_EINDEX_NUM - 1;

	for(i = 0; i < d_Lcl_ENA_LTTbl_EEPROM_size / 2; i++){
		for(j = 0; j < d_Lcl_ENA_EINDEX_NUM; j++){
			*pus2-- = *pus;
		}
		pus--;
	}
	

	
	// TT table
	app_readROM(Gd_ENA_RomAdr + d_Lcl_ENA_TTTbl_EEPROM_adr, d_Lcl_ENA_TTTbl_EEPROM_size,
																(unsigned char *)&Gus_ENA_TT[0]);
	pus = &Gus_ENA_TT[0];
	for(i = 0; i < d_Lcl_ENA_TTTbl_EEPROM_size / 2; i++){
#ifdef d_ENA_LITTLE_ENDIAN
		*pus++ &= 0xff03;
#else
		*pus++ &= 0x03ff;
#endif
	}

	// MT table
	app_readROM(Gd_ENA_RomAdr + d_Lcl_ENA_MTTbl_EEPROM_adr, d_Lcl_ENA_MTTbl_EEPROM_size, &Guc_ENA_MT[0]);
	puc = &Guc_ENA_MT[0];
	for(i = 0; i < d_Lcl_ENA_MTTbl_EEPROM_size; i++){
		*puc++ &= 0x7f;
	}
	
	return TRUE;
}