/*******************************************************************************
*   モジュール名称      ：アプリケーション02 - HK read & anaylses - MPPE/ENA   *
*   参考                ：  app02_DPU.c を参照                                 *
*   注意				：  EDIT権限は、MPPE/ENA組                             *
*   作成日・作成者      ：2010/07/02    Y.K.                                   *
*   作成日・作成者      ：2012/03/07    Y.K.                                   *
*******************************************************************************/


//#define		d_SIZEhk_ENA		128		// HK-size	0x80  -- app_MPPE-ENA.h で定義する。


#include "app_MPPE-ENA.h"



// ********************************************************************
// *** ENA :  HK analyses, HW CMD production, HK packet production ***
// ********************************************************************
int		app02_ENA ( unsigned char  uc_dataHK[], unsigned int ui_counter, unsigned char uc_link)
{
	static int si_linkupcallnum = 0;
	
#ifdef	d_ENA_DEBUG_AUTODISCRI_MDP
	static unsigned int ui_callcount = 0;
#endif
	
//	unsigned char	uc_dpuSwHk[0x100];
//	int				i_dpuSwHK_size = 0;
	int				i;
	unsigned int	ui;
	unsigned char	*puc, *puc2, *puc_hwhk, uc_buf[d_Lcl_ENA_SensorCMD_MaxLen];
	
	M_T_TIME_INFO	t_timeInfo;	// 衛星時刻
	
#ifdef	d_ENA_DEBUG_AUTODISCRI_MDP
	ui_callcount++;
#endif
	
#ifdef	d_ENA_LOCAL_EMU
//	int lcl_i;
#endif

	// *************************
	// ***	HW HK analyses   ***
	// *************************
	if ( uc_link ) {
		// --- HW-ON  ---
		puc  = &uc_dataHK[d_SIZEhk_ENA - 1];
		puc2 = &uc_dataHK[d_Lcl_ENA_SWHK_SIZE + d_SIZEhk_ENA - 1];
		for(i = 0; i < d_SIZEhk_ENA; i++){
			*puc2-- = *puc--;
		}
	}
//	else {
//		// --- HW-OFF ---
//		// センサーオフ時に HW-HK を出さない場合、ゼロクリアは必要ない。
//		puc = &uc_dataHK[d_Lcl_ENA_SWHK_SIZE];
//		for (i = 0; i < d_SIZEhk_ENA; i++){
//			*puc++ = 0;
//		}
//	}

	puc_hwhk = &uc_dataHK[d_Lcl_ENA_SWHK_SIZE];

	// *************************
	// ***	SW/HK production ***
	// *************************
	
	// software HK セット
	app02_ENA_SWHKset(&uc_dataHK[0], uc_link);
			

	
	if ( ! uc_link ) {

		// --- HW-OFF ---
		si_linkupcallnum = 0;
		
		Gs_ENA_prm.s_saveparam.uc_linkSpW	= d_Lcl_ENAHK_UnLinkSpW;
		
		Gs_ENA_prm.uc_reqSensorInit			= TRUE;		// センサー初期化要求フラグ
		
	}
	else {
		// --- HW-ON  ---
		si_linkupcallnum++;
		if(si_linkupcallnum > 3){ si_linkupcallnum = 3; }
		
		Gs_ENA_prm.s_sHK.us_ctrBase			= (((unsigned short)puc_hwhk[14]) << 8) | puc_hwhk[15];
		
		if(si_linkupcallnum <= 2){
			Gs_ENA_prm.uc_reqSensorInit		= TRUE;		// センサー初期化要求フラグ
			Gs_ENA_prm.s_sHK.us_ctrBase0	= Gs_ENA_prm.s_sHK.us_ctrBase;
		}
		
		if(si_linkupcallnum >= 3){
			
			// 初期化要求時の処理
			if(Gs_ENA_prm.uc_reqSensorInit == TRUE){
				if(Gs_ENA_prm.s_sHK.us_ctrBase0 != Gs_ENA_prm.s_sHK.us_ctrBase){

					// 変数の初期化
					uc_buf[0] = TRUE;
					app01_ENA_2(d_Lcl_ENA_CMD_INITPARAM, &uc_buf[0], 1, FALSE);

					// 初期化要求フラグはおろす。
					Gs_ENA_prm.uc_reqSensorInit = FALSE;
					
					
//					// MDP 内に残っている処理前のブロックデータをクリアする
//					app01_ENA_2(d_Lcl_ENA_CMD_BLOCK_CLR, &uc_buf[0], 0, FALSE);
//				
//					// EEPROM から MDP RAM への lookup テーブル読み込み
//					app01_ENA_2(d_Lcl_ENA_CMD_LOOKUP_TBL_WRITE_MDP, &uc_buf[0], 0, FALSE);

					// マクロコマンド強制停止
					app01_ENA_2(d_Lcl_ENA_CMD_MacroFORCESTOP, &uc_buf[0], 0, FALSE);
					
					// マクロコマンド実行要求受付 enable
					uc_buf[0] = TRUE;
					app01_ENA_2(d_Lcl_ENA_CMD_MACRO_ENA, &uc_buf[0], 1, FALSE);
					
					// マクロコマンド実行要求
					// マクロコマンドテーブル ID: d_Lcl_ENA_Initialize_MacroCmdTableID
					// マクロコマンド ID:         d_Lcl_ENA_Initialize_MacroCmdID
					uc_buf[0] = d_Lcl_ENA_Initialize_MacroCmdTableID;
					uc_buf[1] = d_Lcl_ENA_Initialize_MacroCmdID;
					app01_ENA_2(d_Lcl_ENA_CMD_MacroREQ, &uc_buf[0], 2, FALSE);
				}
			}
			// ベースカウンタ値 (1回前の HK 読み込み時の値) を更新
			Gs_ENA_prm.s_sHK.us_ctrBase0 = Gs_ENA_prm.s_sHK.us_ctrBase;
			

		
			Gs_ENA_prm.s_saveparam.uc_linkSpW	= d_Lcl_ENAHK_LinkSpW;
		
			Gs_ENA_prm.s_sHK.uc_rmapctr			= puc_hwhk[0];
			Gs_ENA_prm.s_sHK.uc_cmdctr			= puc_hwhk[1];
			Gs_ENA_prm.s_sHK.uc_shutdownSU		= (puc_hwhk[2] & 0x08);
			Gs_ENA_prm.s_sHK.uc_shutdownT		= (puc_hwhk[2] & 0x07);
			Gs_ENA_prm.s_sHK.us_ctrSunPulse		= (((unsigned short)puc_hwhk[12]) << 8) | puc_hwhk[13]; 
//			Gs_ENA_prm.s_sHK.us_ctrBase			= (((unsigned short)puc_hwhk[14]) << 8) | puc_hwhk[15];
			Gs_ENA_prm.s_sHK.uc_svtblid[0]		= (0x07 & puc_hwhk[22]);
			Gs_ENA_prm.s_sHK.uc_svtblid[1]		= (0x07 & (puc_hwhk[22] >> 4));
			Gs_ENA_prm.s_sHK.uc_svtblid[2]		= (0x07 & puc_hwhk[23]);
			Gs_ENA_prm.s_sHK.uc_svtblid[3]		= (0x07 & (puc_hwhk[23] >> 4));
			Gs_ENA_prm.s_sHK.uc_discri_data[0]  = (0x03 & (puc_hwhk[27] >> 6));	 // discri
			Gs_ENA_prm.s_sHK.uc_discri_data[1]  = (0x03 & (puc_hwhk[27] >> 4));
			Gs_ENA_prm.s_sHK.uc_discri_data[2]  = (0x03 & (puc_hwhk[27] >> 2));
			Gs_ENA_prm.s_sHK.uc_discri_data[3]  = (0x03 &  puc_hwhk[27]);
			memcpy(&Gs_ENA_prm.s_sHK.uc_discri_data[4], &puc_hwhk[28], d_Lcl_ENA_DISCRITBL_DATANUM - 4);
			Gs_ENA_prm.s_sHK.uc_autodiscri_hk	= puc_hwhk[115];
			Gs_ENA_prm.s_sHK.uc_autodiscri_tblid = (0x01 & (puc_hwhk[115] >> 5));

			// SV table ID
			// SV table ID はどの SV も同一のものを使う。
			// software (データ処理部) 内で参照する SV table ID をセットする
			Gs_ENA_prm.uc_SVRAMid = Gs_ENA_prm.s_sHK.uc_svtblid[0];

#ifdef	d_ENA_AUTODISCRI_MDP		// 120704 KA
			Gs_ENA_prm.s_adis_mdp.ui_addtemp += puc_hwhk[9] * 16 + puc_hwhk[10]/16;
#ifdef	d_ENA_DEBUG_AUTODISCRI_MDP
			Gs_ENA_prm.s_adis_mdp.ui_addtemp -= puc_hwhk[9] * 16 + puc_hwhk[10]/16;
			Gs_ENA_prm.s_adis_mdp.ui_addtemp += (0x0fff & ui_callcount);
#endif
			
			Gs_ENA_prm.s_adis_mdp.us_temp_addnum++;
			if(Gs_ENA_prm.s_adis_mdp.us_temp_addnum >= d_Lcl_ENA_MDPAUTODISCRI_T_ADDNUM){
				Gs_ENA_prm.s_adis_mdp.us_temp = Gs_ENA_prm.s_adis_mdp.ui_addtemp / Gs_ENA_prm.s_adis_mdp.us_temp_addnum;
				Gs_ENA_prm.s_adis_mdp.uc_check_req = TRUE;	// discri table の step のチェック要求を出しておく
				Gs_ENA_prm.s_adis_mdp.ui_addtemp   = 0;
				Gs_ENA_prm.s_adis_mdp.us_temp_addnum  = 0;
			}
			
#ifdef	d_ENA_LOCAL_EMU
			fprintf(stdout, "ADIS_IFET %3x %08x %d %3x\n", Gs_ENA_prm.s_adis_mdp.us_temp,
				Gs_ENA_prm.s_adis_mdp.ui_addtemp, Gs_ENA_prm.s_adis_mdp.us_temp_addnum,
				puc_hwhk[9] * 16 + puc_hwhk[10]/16);
#endif
			if(Gs_ENA_prm.s_adis_mdp.uc_autoena == FALSE){
				Gs_ENA_prm.s_adis_mdp.uc_check_req = FALSE;  // discri table の step をチェックしない
			}
			else {
				// 自動ディスクリ変更 ena コマンドを受け付けた直後は discri 変更要求を出す。
				if(Gs_ENA_prm.s_adis_mdp.uc_autoena_past == FALSE){
					Gs_ENA_prm.s_adis_mdp.uc_autoena_past = TRUE;
					Gs_ENA_prm.s_adis_mdp.uc_check_req    = TRUE; // discri step のチェック要求を出す
					Gs_ENA_prm.s_adis_mdp.uc_chg_req      = TRUE; // discri 変更要求を出す
#ifdef	d_ENA_LOCAL_EMU
			fprintf(stdout, "ADIS_IFET ena cmd recv\n");
#endif
				}
				if(Gs_ENA_prm.s_adis_mdp.uc_tblchg_recv == TRUE){
#ifdef	d_ENA_LOCAL_EMU
			fprintf(stdout, "ADIS_IFET tbl chg recv\n");
#endif
					Gs_ENA_prm.s_adis_mdp.uc_tblchg_recv  = FALSE;
					Gs_ENA_prm.s_adis_mdp.uc_check_req    = TRUE; // discri step のチェック要求を出す
					Gs_ENA_prm.s_adis_mdp.uc_chg_req      = TRUE; // discri 変更要求を出す
				}
			}
			
			// duscri table の step をチェックし、変わる場合にはディスクリ変更要求を出す
			if(Gs_ENA_prm.s_adis_mdp.uc_check_req == TRUE){
				Gs_ENA_prm.s_adis_mdp.uc_check_req = FALSE;
				
#ifdef	d_ENA_LOCAL_EMU
			fprintf(stdout, "ADIS_IFET check request\n");
#endif
				// 温度値が取得できていない場合には discri 変更要求はださない (だせない)
				if(Gs_ENA_prm.s_adis_mdp.us_temp > 0xfff){
					Gs_ENA_prm.s_adis_mdp.uc_chg_req = FALSE; 
				}
				else {
					for(i = 0; i < d_Lcl_ENA_AUTODISCRITBL_TNUM; i++){
						puc = &Gs_ENA_prm.s_adis_mdp.uc_tbl_adiscri[Gs_ENA_prm.s_adis_mdp.uc_tblid][i][0];
						ui = ((0x0f & *puc) << 8) + *(puc + 1);
						if(Gs_ENA_prm.s_adis_mdp.us_temp <= ui){
							break;
						}
						if(ui == 0xfff){
							break;
						}
					}
					
					// step が見つからない場合、最終ステップとする。
					if(i >= d_Lcl_ENA_AUTODISCRITBL_TNUM){
						i = d_Lcl_ENA_AUTODISCRITBL_TNUM - 1;
					}
					// 現在の step と今回温度値から出した step が異なる場合、ディスクリ変更要求をだす。
					// i >= d_Lcl_ENA_AUTODISCRITBL_TNUM の場合は
					//    ステップが見つからない場合に相当する。
					if(i != Gs_ENA_prm.s_adis_mdp.uc_curstep){
						Gs_ENA_prm.s_adis_mdp.uc_curstep2 = i;
						Gs_ENA_prm.s_adis_mdp.uc_chg_req  = TRUE;
					}
#ifdef	d_ENA_LOCAL_EMU
			fprintf(stdout, "ADIS_IFET check step %2x thresT %3x curT %x\n", i, ui, Gs_ENA_prm.s_adis_mdp.us_temp);
#endif
				}
			}
#endif


			// マクロコマンド実行
			if(Gs_ENA_prm.s_MacroCmd.uc_req == TRUE
					|| Gs_ENA_prm.s_MacroCmd.s_mcp.c_status == d_MacroCmd_WAIT
					|| Gs_ENA_prm.s_MacroCmd.s_mcp.c_status == d_MacroCmd_EXEC
					|| Gs_ENA_prm.s_MacroCmd.s_mcp.c_status == d_MacroCmd_EXECREQ ){

				Gs_ENA_prm.s_MacroCmd.uc_req = FALSE;
		
				// 1回コールすると 1ステップ進む。
				// センサーへの直接コマンドは関数内で送信される。
				Gs_ENA_prm.s_MacroCmd.i_rtnval = app_macrocmd_cont(Gd_N_ENA, &(Gs_ENA_prm.s_MacroCmd.s_mcp), d_MacroCmd_CONT_EXEC);
		
				// MDP ユーザーコマンド実行要求処理
				if(Gs_ENA_prm.s_MacroCmd.s_mcp.c_status == d_MacroCmd_EXECREQ){
					ui = 0x100 * Gs_ENA_prm.s_MacroCmd.s_mcp.uc_cmd[0] + Gs_ENA_prm.s_MacroCmd.s_mcp.uc_cmd[1];
					i = 0;
					if(Gs_ENA_prm.s_MacroCmd.s_mcp.selectmacro.cmdcur.uc_size > 2){
						i = Gs_ENA_prm.s_MacroCmd.s_mcp.selectmacro.cmdcur.uc_size - 2;
					}
			
					// マクロコマンド内でマクロコマンド実行要求は受け付けない (無視)
					if(ui != d_Lcl_ENA_CMD_MacroREQ){
						// MDP ユーザーコマンド実行
						app01_ENA_2(ui, &Gs_ENA_prm.s_MacroCmd.s_mcp.uc_cmd[2], i, FALSE);
					}
				}
			}

#ifdef	d_ENA_AUTODISCRI_MDP		// 120704 KA
			// ディスクリ値変更要求検査 (MDP アプリケーションによる autodiscri 機能を使う場合)
			if(Gs_ENA_prm.s_adis_mdp.uc_chg_req){
				Gs_ENA_prm.s_adis_mdp.uc_chg_req      = FALSE;
				Gs_ENA_prm.s_adis_mdp.uc_wrt_target   = TRUE;
				Gs_ENA_prm.s_adis_mdp.uc_wrtcount_rem = 0;
				Gs_ENA_prm.s_adis_mdp.uc_curstep      = Gs_ENA_prm.s_adis_mdp.uc_curstep2;
#ifdef	d_ENA_LOCAL_EMU
				fprintf(stdout, "ADIS_IFET target set %2x\n", Gs_ENA_prm.s_adis_mdp.uc_curstep);
#endif
			}
#endif
			// IFE へのテーブル書き込み実行要求検査 (SV, autodiscri)
			if(Gs_ENA_prm.s_tblws.uc_wrt_req){
				Gs_ENA_prm.s_tblws.uc_wrt_req    = FALSE;
				Gs_ENA_prm.s_tblws.uc_wrt_target = (0x3f & Gs_ENA_prm.s_tblws.uc_wrt_target0); // 上位 2ビットは無効
			}
			// IFE へのテーブル書き込み実行要求検査 (manual discri)
			if(Gs_ENA_prm.s_tblws.uc_wrt_req_mdis){
				Gs_ENA_prm.s_tblws.uc_wrt_req_mdis    = FALSE;
				Gs_ENA_prm.s_tblws.uc_wrt_target_mdis = TRUE;
			}
			// IFE へのテーブル書き込み
			if(Gs_ENA_prm.s_tblws.uc_wrt_target | Gs_ENA_prm.s_tblws.uc_wrt_target_mdis){
				Gs_ENA_prm.s_tblws.uc_endsts = FALSE;		// 書き込み中
				app02_ENA_TableWrite_toSensor();			// テーブル書き込み
			}
#ifdef	d_ENA_AUTODISCRI_MDP		// 120704 KA
			// ディスクリ変更の場合、19コマンド必要となる。テーブル書き込みと重なると
			// コマンドリジェクトとなる可能性があるため、テーブル書き込み時を避けてディスクリを変更する。
			else if(Gs_ENA_prm.s_adis_mdp.uc_wrt_target){
#ifdef	d_ENA_LOCAL_EMU
				fprintf(stdout, "ADIS_IFET AAA\n");
#endif
				app02_ENA_DiscriChg_AutoMDP_toSensor();			// テーブル書き込み
			}
#endif

			// SV table id 変更コマンドの送信 (データ処理モード変更時への対応)
			if(Gs_ENA_prm.uc_svtbl_chgreq == TRUE){
				Gs_ENA_prm.uc_svtbl_chgreq = FALSE;
				Gs_ENA_prm.uc_svtnl_chg_waitcount++;
			}
			else if(Gs_ENA_prm.uc_svtnl_chg_waitcount == 1){
				Gs_ENA_prm.uc_svtnl_chg_waitcount = 0;
				uc_buf[0] = Gs_ENA_prm.uc_svtbl_idtgt;
				app01_ENA_2(d_Lcl_ENA_CMD_ENGY_TBL_SEL, &uc_buf[0], 1, FALSE);
			}
			
			
			
		}
	}
	
	

	// ミッションTLM への HK データ出力
	if(Gs_ENA_prm.s_oHK.uc_clearctr_req == TRUE){
		Gs_ENA_prm.s_oHK.uc_clearctr_req = FALSE;
		Gs_ENA_prm.s_oHK.ui_outinterval_ctr = d_Lcl_ENA_MISSION_PCKT_OUTHK_INITCTR;
	}
	if(Gs_ENA_prm.s_oHK.ui_outinterval != 0){
		if(Gs_ENA_prm.s_oHK.ui_outinterval_ctr > Gs_ENA_prm.s_oHK.ui_outinterval){
			Gs_ENA_prm.s_oHK.ui_outinterval_ctr = Gs_ENA_prm.s_oHK.ui_outinterval;
		}
		
		// このようなことはないはずだが念のため。
		if(Gs_ENA_prm.s_oHK.ui_outinterval_ctr == 0){
			Gs_ENA_prm.s_oHK.ui_outinterval_ctr = 1;
		}
		
		Gs_ENA_prm.s_oHK.ui_outinterval_ctr--;
		
		if(Gs_ENA_prm.s_oHK.ui_outinterval_ctr == 0){
			Gs_ENA_prm.s_oHK.ui_outinterval_ctr = Gs_ENA_prm.s_oHK.ui_outinterval;

			// センサーオフで未処理ブロックがない場合、mission データへの HK データ出力をしない。
			// ただし、未処理ブロックがなくなっても最初の 2回は出力される。
			// Gs_ENA_prm.s_mdb.us_numNewBlock は app_SetNonProcBlock() の戻り値。未処理ブロックがない場合、int で負値が格納される。
			if(uc_link == 0 && (Gs_ENA_prm.s_mdb.us_numNewBlock == 0 || 0xfff0 < Gs_ENA_prm.s_mdb.us_numNewBlock)){
				if(Gs_ENA_prm.s_mdb.uc_noblockstate < 3){ Gs_ENA_prm.s_mdb.uc_noblockstate++; }
			}
			else {
				Gs_ENA_prm.s_mdb.uc_noblockstate = 0;
			}
			
			if(Gs_ENA_prm.s_mdb.uc_noblockstate < 3){

				// 現在時刻の取得
				// sunpulse 時間が更新されてから current time が更新されるまでの間に時刻取得がなされると
				//   sunpulse 時刻の方が後になる場合がある。これを防ぐ。 (120311)
				while (TRUE){
					dpu_getTime(&t_timeInfo );
					if ( t_timeInfo.ui_sunpulseTime <=  t_timeInfo.ui_currentTime )  break;
				}
//				dpu_getTime( &t_timeInfo );

			
				// ローカルバッファへ HK 内容をコピーする。
#ifdef	d_ENA_ATTEMPT_TO_SMALLSIZE2		// 120416
				memcpy(&Guc_ENA_HK_localbuf[d_Lcl_ENA_MISSION_PCKT_OUTHK_HEADA_SIZE],
										&uc_dataHK[0], d_SIZEhk_ENA + d_Lcl_ENA_SWHK_SIZE);
#else
				puc  = &uc_dataHK[0];
				puc2 = &Guc_ENA_HK_localbuf[d_Lcl_ENA_MISSION_PCKT_OUTHK_HEADA_SIZE];
				for(i = 0; i < d_SIZEhk_ENA + d_Lcl_ENA_SWHK_SIZE; i++){
					*puc2++ = *puc++;
				}
#endif
				puc = &Guc_ENA_HK_localbuf[0];
				*(unsigned short *)puc = LCLEMU_htons(d_Lcl_ENA_MODEID_HKtoMISSIONTLM);
				puc += 2;
				puc += 2;																// サイズが入力されるため、空ける
				*(unsigned int *)puc   = LCLEMU_htonl(t_timeInfo.ui_sunpulseTime);
				puc += 4;
				*(unsigned short *)puc = LCLEMU_htons(t_timeInfo.ui_currentTime - t_timeInfo.ui_sunpulseTime);
				puc += 2;
				puc += 2;																// 4 byte 境界のため
				*(unsigned int *)puc   = LCLEMU_htonl(t_timeInfo.ui_currentTime2);
		
				// テレメ出力バッファのクリア
				Gs_ENA_prm.s_omt[d_Lcl_ENA_MISTLMOUTBUFID_HK].uc_flg_bufempty = TRUE;
			
				// データレコーダへの伝送
				app04_ENA_tlmout(&Guc_ENA_HK_localbuf[0],
										d_Lcl_ENA_MISSION_PCKT_OUTHK_PCKTSIZE,
										FALSE,						// mission データとして出す HK データ
										TRUE);						// 新データ
			}
		}
	}
	
	// ******************************
	// ***	HK Production in 'OFF ***
	// ******************************
//	if ( uc_link == 0 ) return( 0 );
//	else			  	return( d_SIZEhk_ENA+i_dpuSwHK_size );

	if ( uc_link == 0 ) return( d_Lcl_ENA_SWHK_SIZE );
	else			  	return( d_Lcl_ENA_SWHK_SIZE + d_SIZEhk_ENA );
}



//
// software HK 生成
//
char app02_ENA_SWHKset(unsigned char *puc, unsigned char uc_link)
{
	unsigned char uc, uc2;
	unsigned char uc3;
	int i;
//			if ( i_dpuSwHK_size > 0)	memcpy( &uc_dataHK[d_SIZEhk_ENA], uc_dpuSwHk, i_dpuSwHK_size );
//			else						i_dpuSwHK_size = 0;

	// SpaceWire link status, command rejection counter	
	puc[0] = ( ((0x01 & uc_link) << 7) | (0x7f & Gs_ENA_prm.s_saveparam.uc_cmderrctr) );
	
	// command counter
	puc[1] = Gs_ENA_prm.s_saveparam.uc_cmdctr;
	
	// コマンドアンサ
	puc[2] = Gs_ENA_prm.s_saveparam.uc_cmdanswer[0];
	puc[3] = Gs_ENA_prm.s_saveparam.uc_cmdanswer[1];
	puc[4] = Gs_ENA_prm.s_saveparam.uc_cmdanswer[2];
	puc[5] = Gs_ENA_prm.s_saveparam.uc_cmdanswer[3];

	// マクロコマンド、テーブルライトステータス
	puc[6] = ( (Gs_ENA_prm.s_tblws.uc_endsts << 7)							// table write (to IFE) status
					| ((Gs_ENA_prm.s_dmp.us_dump_target == 0 ? 0 : 1) << 6)	// table dump end
					| ( (0x01 & Gs_ENA_prm.s_MacroCmd.uc_cmdenaflg) << 5) 	// マクロコマンド実行要求受付 ena/dis
					| Gs_ENA_prm.uc_macrocmdtableID );						// マクロコマンドテーブルID
	puc[7] = Gs_ENA_prm.s_MacroCmd.s_mcp.us_macroID;						// マクロコマンド ID
	
	// マクロコマンドステータス
	// Gs_ENA_prm.s_MacroCmd.i_rtnval の負値は 0x10 からの減算によって表す。
	i = Gs_ENA_prm.s_MacroCmd.i_rtnval;
	if(Gs_ENA_prm.s_MacroCmd.i_rtnval < 0){
		i = 0x10 + Gs_ENA_prm.s_MacroCmd.i_rtnval;
	}
	puc[8] = ( (i << 4) | (0x0f & Gs_ENA_prm.s_MacroCmd.s_mcp.c_status) );
	
	// mission データとして出す HK パケットの生成間隔
	puc[9] = (0x0f & Gs_ENA_prm.s_oHK.uc_outinterval_encoded);
	
	// 送信パケット数 (ターゲット値) (engineering, table read, non-process modes)
	puc[10] = (Gs_ENA_prm.s_npm.us_numpckt_tgt >> 8);
	puc[11] = (0x00ff & Gs_ENA_prm.s_npm.us_numpckt_tgt);
	// 送信したパケット数 (現在値) (engineering, table read, non-process modes)
	puc[12] = (Gs_ENA_prm.s_npm.us_numpckt_sent >> 8);
	puc[13] = (0x00ff & Gs_ENA_prm.s_npm.us_numpckt_sent);
	
	// bin 数
//#ifdef	d_ENA_ATTEMPT_TO_SMALLSIZE
//	こちらのコードの方が 32バイト大きい
//	uc3 = Gs_ENA_prm.uc_numP;
//	if(uc3 == 1)		{ uc = 0; }
//	else if(uc3 == 2)	{ uc = 1; }
//	else if(uc3 == 4)	{ uc = 2; }
//	else if(uc3 == 8)	{ uc = 3; }
//	else if(uc3 == 16)	{ uc = 4; }
//	else if(uc3 == 32)	{ uc = 5; }
//	else 				{ uc = 6; }
	
//#else
	switch(Gs_ENA_prm.uc_numP){ // スピンフェーズ分割数
		case 1:
			uc = 0;
			break;
		case 2:
			uc = 1;
			break;
		case 4:
			uc = 2;
			break;
		case 8:
			uc = 3;
			break;
		case 16:
			uc = 4;
			break;
		case 32:
			uc = 5;
			break;
		default:
			uc = 6;
			break;
	}
//#endif
	uc2 = ((0x07 & uc) << 5);

#ifdef	d_ENA_ATTEMPT_TO_SMALLSIZE
	uc3 = Gs_ENA_prm.uc_numC;
	if(uc3 == 1)		{ uc = 0; }
	else if(uc3 == 2)	{ uc = 1; }
	else if(uc3 == 7)	{ uc = 2; }
	else 				{ uc = 3; }
#else
	switch(Gs_ENA_prm.uc_numC){ // セクター分割数
		case 1:
			uc = 0;
			break;
		case 2:
			uc = 1;
			break;
		case 7:
			uc = 2;
			break;
		case 8:
		default:
			uc = 3;
			break;
	}
#endif
	uc2 |= ((0x03 & uc) << 2);
	
#ifdef	d_ENA_ATTEMPT_TO_SMALLSIZE
	uc3 = Gs_ENA_prm.uc_numE;
	if(uc3 == 1)		{ uc = 0; }
	else if(uc3 == 2)	{ uc = 1; }
	else if(uc3 == 4)	{ uc = 2; }
	else 				{ uc = 3; }
#else
	switch(Gs_ENA_prm.uc_numE){ // energy bin 分割数
		case 1:
			uc = 0;
			break;
		case 2:
			uc = 1;
			break;
		case 4:
			uc = 2;
			break;
		case 8:
		default:
			uc = 3;
			break;
	}
#endif
	puc[14] = (uc2 | (0x03 & uc));
	
	// Process mode, mass bin 数
#ifdef	d_ENA_ATTEMPT_TO_SMALLSIZE
	uc3 = Gs_ENA_prm.uc_numM;
	if(uc3 == 1)		{ uc = 0; }
	else if(uc3 == 2)	{ uc = 1; }
	else if(uc3 == 4)	{ uc = 2; }
	else if(uc3 == 8)	{ uc = 3; }
	else if(uc3 == 16)	{ uc = 4; }
	else if(uc3 == 32)	{ uc = 5; }
	else if(uc3 == 64)	{ uc = 6; }
	else if(uc3 == 128)	{ uc = 7; }
	else 				{ uc = 8; }
#else
	switch(Gs_ENA_prm.uc_numM){ // mass bin 分割数
		case 1:
			uc = 0;
			break;
		case 2:
			uc = 1;
			break;
		case 4:
			uc = 2;
			break;
		case 8:
			uc = 3;
			break;
		case 16:
			uc = 4;
			break;
		case 32:
			uc = 5;
			break;
		case 64:
			uc = 6;
			break;
		case 128:
			uc = 7;
			break;
		default:
			uc = 8;
			break;
	}
#endif	
	puc[15] = ( (0x0f & Gs_ENA_prm.uc_ProcessMode) << 4)	// process モード
					| (0x0f & uc);							// mass bin 分割数
	
	// データ重ね合わせ/処理間隔
	// データ処理を行うスピン時に処理するIFE データパケット数(engineering, table read, nonprocess モード)
	puc[16] = ( (0x0f & Gs_ENA_prm.uc_num_add_interval_Spin_encoded) << 4 )
					| (0x07 & Gs_ENA_prm.s_npm.uc_numProcessPckt_inSpin_encoded);
	
	// データ処理する slot 数 / 4 (1スピン中で)
	// データ処理を開始する slotID / 4
//#ifdef	d_ENA_ATTEMPT_TO_SMALLSIZE
//  このコードの方が 40バイト大きい
//	uc3 = Gs_ENA_prm.uc_lenP;
//	if(uc3 == 1)		{ uc = 0; }
//	else if(uc3 == 2)	{ uc = 1; }
//	else if(uc3 == 4)	{ uc = 2; }
//	else if(uc3 == 8)	{ uc = 3; }
//	else if(uc3 == 16)	{ uc = 4; }
//	else if(uc3 == 32)	{ uc = 5; }
//	else 				{ uc = 6; }
//#else
	switch(Gs_ENA_prm.uc_lenP){
		case 1:
			uc = 0;
			break;
		case 2:
			uc = 1;
			break;
		case 4:
			uc = 2;
			break;
		case 8:
			uc = 3;
			break;
		case 16:
			uc = 4;
			break;
		case 32:
			uc = 5;
			break;
		default:
			uc = 6;
			break;
	}
//#endif
	
//	2013.6.8
//	puc[17] = ((0x03 & uc) << 5) | (0x1f & Gs_ENA_prm.uc_startP);
	puc[17] = ((0x07 & uc) << 5) | (0x1f & Gs_ENA_prm.uc_startP);
	
	// 圧縮モード
	puc[18] = ((0x01 & Gs_ENA_prm.uc_reqUserreqcmd) << 7)		// ユーザリクエストコマンド送信フラグ
					| ((0x03 & Gs_ENA_prm.uc_CntDepth) << 4)	// LinLog 圧縮をする際の元カウンタの depth
					| ((0x03 & Gs_ENA_prm.uc_CprsWayFlg) << 2)	// 圧縮モード
//					| 											// TODO: NON-coincidence rep on/off
//					|											// TODO: health check on/off
					;
	
	// ユーザーリクエストコマンドの送信理由
	puc[19] = Gs_ENA_prm.uc_reqUserreqcmd_reason;
	
	// TODO: health check interval
	// lookup table ID
	puc[20] = (0x0f & Gs_ENA_prm.uc_SVRAMid);
	
	// mass factor
	puc[21] = (Gs_ENA_prm.us_MassFactor >> 8);
	puc[22] = (0x00ff & Gs_ENA_prm.us_MassFactor);
	
	// LinLog 圧縮時に差し引くカウントオフセット
	memcpy( &(puc[23]), (unsigned char *)&(Gs_ENA_prm.ui_CntOffset), 4);	// corrected by YK @ 120307, 120406KA
	// puc[23] = (Gs_ENA_prm.ui_CntOffset >> 24);							// corrected by YK @ 120307
	// puc[24] = ((0x00ff0000 & Gs_ENA_prm.ui_CntOffset) >> 16);			// corrected by YK @ 120307
	// puc[25] = ((0x0000ff00 & Gs_ENA_prm.ui_CntOffset) >> 8);				// corrected by YK @ 120307
	// puc[26] = ( 0x000000ff & Gs_ENA_prm.ui_CntOffset);					// corrected by YK @ 120307
	
	// 未処理ブロック数 (long buffer)
	puc[27] = (Gs_ENA_prm.s_mdb.us_numNewBlock >> 8);
	puc[28] = (0x00ff & Gs_ENA_prm.s_mdb.us_numNewBlock);
	
	// 処理済ブロック (long buffer) の TI の最新値
	memcpy( &(puc[29]), (unsigned char *)&(Gui_TLMm_blockTime[Gd_N_ENA]), 4);	// corrected by YK @ 120307, 120406KA
	// puc[29] = (Gui_TLMm_blockTime[Gd_N_ENA] >> 24);						// corrected by YK @ 120307
	// puc[30] = ((0x00ff0000 & Gui_TLMm_blockTime[Gd_N_ENA]) >> 16);		// corrected by YK @ 120307
	// puc[31] = ((0x0000ff00 & Gui_TLMm_blockTime[Gd_N_ENA]) >> 8);		// corrected by YK @ 120307
	// puc[32] = ( 0x000000ff & Gui_TLMm_blockTime[Gd_N_ENA]);				// corrected by YK @ 120307

	// トリガ
	puc[33] = (Gs_ENA_prm.uc_trg_prenum << 4) + (Gs_ENA_prm.uc_trg_postnum & 0x0f);
	puc[34] = Gs_ENA_prm.uc_trg_precnt10;
	puc[35] = (Gs_ENA_prm.uc_trg_ena << 7)						// trigger enable/disable
				+ ((Gs_ENA_prm.uc_trg_acqmode & 0x03) << 5)		// mode (相対増加/絶対値)
				+ (Gs_ENA_prm.uc_trg_precnt11 & 0x1f);
	puc[36] = Gs_ENA_prm.uc_trg_postcnt10;
	puc[37] = (Gs_ENA_prm.uc_trgset_flagset << 7)	// 最新の trigger イベントに対し、共通ルーチンにフラグセットをしたかどうか	
				+ (Gs_ENA_prm.uc_trg_postcnt11 & 0x1f);
	
	// トリガ時 TI
	memcpy( &(puc[38]), (unsigned char *)&(Gs_ENA_prm.ui_trgset_ti), 4);	// corrected by YK @ 120307, 120406KA
	// puc[38] = (Gs_ENA_prm.ui_trgset_ti >> 24);							// corrected by YK @ 120307
	// puc[39] = ((0x00ff0000 & Gs_ENA_prm.ui_trgset_ti) >> 16);			// corrected by YK @ 120307
	// puc[40] = ((0x0000ff00 & Gs_ENA_prm.ui_trgset_ti) >> 8);				// corrected by YK @ 120307
	// puc[41] = ( 0x000000ff & Gs_ENA_prm.ui_trgset_ti);					// corrected by YK @ 120307
	// トリガ時 トリガ前カウント値
	memcpy( &(puc[42]), (unsigned char *)&(Gs_ENA_prm.ui_trgset_precnt), 4);	// corrected by YK @ 120307, 120406KA
	// puc[42] = (Gs_ENA_prm.ui_trgset_precnt >> 24);						// corrected by YK @ 120307
	// puc[43] = ((0x00ff0000 & Gs_ENA_prm.ui_trgset_precnt) >> 16);		// corrected by YK @ 120307
	// puc[44] = ((0x0000ff00 & Gs_ENA_prm.ui_trgset_precnt) >> 8);			// corrected by YK @ 120307
	// puc[45] = ( 0x000000ff & Gs_ENA_prm.ui_trgset_precnt);				// corrected by YK @ 120307
	// トリガ時 トリガ後カウント値
	memcpy( &(puc[46]), (unsigned char *)&(Gs_ENA_prm.ui_trgset_postcnt), 4);	// corrected by YK @ 120307, 120406KA
	// puc[46] = (Gs_ENA_prm.ui_trgset_postcnt >> 24);						// corrected by YK @ 120307
	// puc[47] = ((0x00ff0000 & Gs_ENA_prm.ui_trgset_postcnt) >> 16);		// corrected by YK @ 120307
	// puc[48] = ((0x0000ff00 & Gs_ENA_prm.ui_trgset_postcnt) >> 8);		// corrected by YK @ 120307
	// puc[49] = ( 0x000000ff & Gs_ENA_prm.ui_trgset_postcnt);				// corrected by YK @ 120307
	
#ifdef	d_ENA_AUTODISCRI_MDP		// 120704 KA
	// 自動ディスクリ変更機能 (MDP アプリケーションによる機能)
	uc = 0x40;
	if(Gs_ENA_prm.s_adis_mdp.uc_tblid == 0){
		uc = 0x20;
	}
	Gs_ENA_prm.s_adis_mdp.uc_autodiscri_hk = 
				(0x80 & (Gs_ENA_prm.s_adis_mdp.uc_autoena << 7)) | uc | (0x1f & Gs_ENA_prm.s_adis_mdp.uc_curstep);
	puc[50] = Gs_ENA_prm.s_adis_mdp.uc_autodiscri_hk;
	puc[51] = (0x0f & (Gs_ENA_prm.s_adis_mdp.us_temp >> 8));
	puc[52] = (0xff & Gs_ENA_prm.s_adis_mdp.us_temp);
#endif
	
	return TRUE;
}
	
	
	
	
// テーブル書き込み
// SV、autodiscri テーブル、manual discri に対応
int app02_ENA_TableWrite_toSensor(void)
{
	static unsigned char uc_autodiscri_tblid, uc_svtblid[d_Lcl_ENA_SVNUM];

	unsigned char uc_cmd[d_Lcl_ENA_SensorCMD_MaxLen];
	unsigned char *puc, uc, uc_id, uc_id2, uc_len = 0;
	unsigned short us_offset;
	int i;
	
	struct _s_ENA_TblWriteSensor *pstw;
	

	pstw = &Gs_ENA_prm.s_tblws;
	
	for(i = 0; i < d_Lcl_ENA_SensorCMD_MaxLen; i++){
		uc_cmd[i] = 0;
	}
	uc_cmd[0] = d_Lcl_ENA_SensorCMD_UNDEF;		// コマンド未定義
	
	
	// manual discri data
	if(pstw->uc_wrt_target_mdis){
		if(pstw->uc_wrtcount_rem_mdis == 0 || pstw->uc_wrtcount_rem_mdis > 19 * d_Lcl_ENA_CMDINTVAL_MDISSET){
			
			// 4 (START RING) + 7 (START SECTOR) + 8 (STOP SECTOR) * d_Lcl_ENA_CMDINTVAL_MDISSETsec
			pstw->uc_wrtcount_rem_mdis = 19 * d_Lcl_ENA_CMDINTVAL_MDISSET;
		}

		
		if(pstw->uc_wrtcount_rem_mdis % d_Lcl_ENA_CMDINTVAL_MDISSET == 0){
			
			uc = pstw->uc_wrtcount_rem_mdis / d_Lcl_ENA_CMDINTVAL_MDISSET;

			uc_cmd[0] = d_Lcl_ENA_SensorCMD_SetDiscri;
			uc_cmd[1] = pstw->uc_mdiscri_data[uc - 1];	// discri data
			uc_cmd[2] = 0;
			uc_cmd[3] = 0;
			uc_cmd[4] = 0;
			
			if(uc >= 12){		// STOP SECTOR
				uc_cmd[4] = ( 1 << (uc - 12) );
			}
			else if(uc >= 5){	// START SECTOR
				uc_cmd[3] = ( 1 << (uc - 5) );
			}
			else {										// START RING
				uc_cmd[2] = ( 1 << (uc - 1) );
			}

			app_PiCmd(Gd_N_ENA, uc_cmd, 5);				// コマンド送信
		}
		
		pstw->uc_wrtcount_rem_mdis--;				// カウントダウン
		if(pstw->uc_wrtcount_rem_mdis == 0){
			pstw->uc_wrt_target_mdis = FALSE;		// 処理終了フラグ
		}
	}
	// SV tables
	else if(0x10 & pstw->uc_wrt_target){
		
		if(pstw->uc_wrtcount_rem == 0 || pstw->uc_wrtcount_rem > 79){
			pstw->uc_wrtcount_rem = 79;
			
			for(i = 0; i < d_Lcl_ENA_SVNUM; i++){
				uc_svtblid[i] = Gs_ENA_prm.s_sHK.uc_svtblid[i];
			}
			uc_cmd[0] = d_Lcl_ENA_SensorCMD_SelSVTbl;				// 選択 SV テーブルを 0 にする
			uc_cmd[1] = 0x00;
			uc_cmd[2] = 0x00;
			uc_len    = 3;
		}
		else if(65 <= pstw->uc_wrtcount_rem && pstw->uc_wrtcount_rem <= 68){
			uc_cmd[0] = d_Lcl_ENA_SensorCMD_WriteSVTbl;
			uc_cmd[1] = ((pstw->uc_wrtcount_rem - 65) << 4) + 1;	// SV table 1 に書き込む
																	// テーブル内容は 0 (uc_cmd がクリアされていること)
			uc_len    = 18;
		}
		else if(pstw->uc_wrtcount_rem == 64){
			uc_cmd[0] = d_Lcl_ENA_SensorCMD_SelSVTbl;				// 選択 SV テーブルを 1 にする
			uc_cmd[1] = 0x11;
			uc_cmd[2] = 0x11;
			uc_len    = 3;
		}
		else if(50 <= pstw->uc_wrtcount_rem && pstw->uc_wrtcount_rem <= 53){
			uc_cmd[0] = d_Lcl_ENA_SensorCMD_WriteSVTbl;
			uc_cmd[1] = ((pstw->uc_wrtcount_rem - 50) << 4);		// SV table 0 に書き込む
																	// テーブル内容は 0 (uc_cmd がクリアされていること)
			uc_len    = 18;
		}
		else if(pstw->uc_wrtcount_rem == 49){
			uc_cmd[0] = d_Lcl_ENA_SensorCMD_SelSVTbl;				// 選択 SV テーブルを 0 にする
			uc_cmd[1] = 0x00;
			uc_cmd[2] = 0x00;
			uc_len    = 3;
		}
		else if(11 <= pstw->uc_wrtcount_rem && pstw->uc_wrtcount_rem <= 38){
			uc_cmd[0] = d_Lcl_ENA_SensorCMD_WriteSVTbl;
			
			uc = pstw->uc_wrtcount_rem - 11;
			uc_id  = uc / d_Lcl_ENA_SVNUM + 1;						// SV Table 0 は書かない。
			uc_id2 = uc % d_Lcl_ENA_SVNUM;							// SV id (Wave1, Wave2A, Wave2B, Lens)
			
			uc_cmd[1] = (uc_id2 << 4) + uc_id;
			
			// EEPROM から読み込み
			// EEPROM の SV Table0 領域のデータは無視される。
			app_readROM(Gd_ENA_RomAdr + d_Lcl_ENA_SVTbl_EEPROM_adr + (uc + d_Lcl_ENA_SVNUM) * d_Lcl_ENA_SVDATA_SIZE,
											d_Lcl_ENA_SVDATA_SIZE,
											&uc_cmd[2]);
			for(i = 0; i < d_Lcl_ENA_SVDATA_SIZE; i += 2){
				uc_cmd[2 + i] &= 0x0f;								// SV 制御データは 12bit値
			}
			
			uc_len = 18;
		}
		else if(pstw->uc_wrtcount_rem == 10){
			uc_cmd[0] = d_Lcl_ENA_SensorCMD_SelSVTbl;				// 選択 SV テーブルを元に戻す
			uc_cmd[1] = (uc_svtblid[1] << 4) | uc_svtblid[0];
			uc_cmd[2] = (uc_svtblid[3] << 4) | uc_svtblid[2];
			uc_len    = 3;
		}
			
		if(uc_cmd[0] != d_Lcl_ENA_SensorCMD_UNDEF){
			app_PiCmd(Gd_N_ENA, uc_cmd, uc_len);					// コマンド送信
		}
		
		pstw->uc_wrtcount_rem--;									// カウントダウン
		if(pstw->uc_wrtcount_rem == 0){
			pstw->uc_wrt_target &= (~0x10);							// 処理終了フラグ
		}
	}
	// auto discri table
	else if(0x20 & pstw->uc_wrt_target){

		// EEPROM から読み出し、コマンド送信
		if(0x02 & pstw->uc_wrt_target){
			us_offset = 0;																		// Table 0-1
			if(0x01 & pstw->uc_wrt_target){
				us_offset = 2 * d_Lcl_ENA_AUTODISCRITBL_TNUM * d_Lcl_ENA_AUTODISCRITBL_DATANUM_STORE; // Table 2-3
			}
			
			if(pstw->uc_wrtcount_rem == 0 || pstw->uc_wrtcount_rem > 96){
				pstw->uc_wrtcount_rem = 96;
				uc_autodiscri_tblid = Gs_ENA_prm.s_sHK.uc_autodiscri_tblid;
				
				uc_cmd[0] = d_Lcl_ENA_SensorCMD_SelAutoDiscriTbl;
				uc_cmd[1] = 0x01;										// Table ID 1 選択
				uc_len    = 2;

#ifdef	d_ENA_AUTODISCRI_MDP		// 120704 KA
				app_readROM(Gd_ENA_RomAdr + d_Lcl_ENA_AutoDiscriTbl_EEPROM_adr + us_offset,
											2 * d_Lcl_ENA_AUTODISCRITBL_TNUM * d_Lcl_ENA_AUTODISCRITBL_DATANUM_STORE,
											&Gs_ENA_prm.s_adis_mdp.uc_tbl_adiscri[0][0][0]);
#endif
			}
			else if(54 <= pstw->uc_wrtcount_rem && pstw->uc_wrtcount_rem <= 85){
				uc_cmd[0] = d_Lcl_ENA_SensorCMD_WriteAutoDiscriTbl;
				uc_id     = pstw->uc_wrtcount_rem - 54;					// 温度ステップ
				uc_cmd[1] = uc_id;										// table ID 0, 温度 step
				
				// EEPROM から読み込み
				app_readROM(Gd_ENA_RomAdr + d_Lcl_ENA_AutoDiscriTbl_EEPROM_adr + us_offset
																+ uc_id * d_Lcl_ENA_AUTODISCRITBL_DATANUM_STORE,
											d_Lcl_ENA_AUTODISCRITBL_DATANUM_STORE,
											&uc_cmd[5]);
				uc_cmd[2] = (0x0f & uc_cmd[5]);							// 温度は 12bit値
				uc_cmd[3] = uc_cmd[6];
				uc_cmd[4] = (0x03 & (uc_cmd[7] >> 6));					// format 変換
				uc_cmd[5] = (0x03 & (uc_cmd[7] >> 4));
				uc_cmd[6] = (0x03 & (uc_cmd[7] >> 2));
				uc_cmd[7] = (0x03 & uc_cmd[7]);
				
				uc_len    = 23;
			}
			else if(pstw->uc_wrtcount_rem == 53){
				uc_cmd[0] = d_Lcl_ENA_SensorCMD_SelAutoDiscriTbl;
				uc_cmd[1] = 0x00;										// Table ID 0 選択
				uc_len    = 2;
			}
			else if(11 <= pstw->uc_wrtcount_rem && pstw->uc_wrtcount_rem <= 42){
				uc_cmd[0] = d_Lcl_ENA_SensorCMD_WriteAutoDiscriTbl;
				uc_id     = pstw->uc_wrtcount_rem - 11;					// 温度ステップ
				uc_cmd[1] = (0x80 | uc_id);								// table ID 1, 温度 step
				
				// EEPROM から読み込み
				app_readROM(Gd_ENA_RomAdr + d_Lcl_ENA_AutoDiscriTbl_EEPROM_adr + us_offset
								+ (uc_id + d_Lcl_ENA_AUTODISCRITBL_TNUM) * d_Lcl_ENA_AUTODISCRITBL_DATANUM_STORE,
											d_Lcl_ENA_AUTODISCRITBL_DATANUM_STORE,
											&uc_cmd[5]);
				uc_cmd[2] = (0x0f & uc_cmd[5]);							// 温度は 12bit値
				uc_cmd[3] = uc_cmd[6];
				uc_cmd[4] = (0x03 & (uc_cmd[7] >> 6));					// format 変換
				uc_cmd[5] = (0x03 & (uc_cmd[7] >> 4));
				uc_cmd[6] = (0x03 & (uc_cmd[7] >> 2));
				uc_cmd[7] = (0x03 & uc_cmd[7]);
				
				uc_len    = 23;
			}
			else if(pstw->uc_wrtcount_rem == 10){
				uc_cmd[0] = d_Lcl_ENA_SensorCMD_SelAutoDiscriTbl;
				
				// 選択テーブルを元に戻す
				// HK 値とコマンド制御値が異なるので注意
				if(uc_autodiscri_tblid == 2)	{ uc_cmd[1] = 1; }
				else							{ uc_cmd[1] = 0; }
				
				uc_len    = 2;
			}
			
			if(uc_cmd[0] != d_Lcl_ENA_SensorCMD_UNDEF){
				app_PiCmd(Gd_N_ENA, uc_cmd, uc_len);					// コマンド送信
			}
		
			pstw->uc_wrtcount_rem--;									// カウントダウン
			if(pstw->uc_wrtcount_rem == 0){
				pstw->uc_wrt_target &= (~0x03);							// 処理終了フラグ
			}
		}
		// MDP RAM から読み出し、コマンド送信
		else if(0x08 & pstw->uc_wrt_target){
			uc_id2 = 0;													// Table ID 0
			if(0x04 & pstw->uc_wrt_target){
				uc_id2 = 1;												// Table ID 1
			}
			if(pstw->uc_wrtcount_rem == 0 || pstw->uc_wrtcount_rem > 53){
				pstw->uc_wrtcount_rem = 53;
				uc_autodiscri_tblid = Gs_ENA_prm.s_sHK.uc_autodiscri_tblid;
				
				uc_cmd[0] = d_Lcl_ENA_SensorCMD_SelAutoDiscriTbl;
				if(uc_id2 == 0){
					uc_cmd[1] = 0x01;									// Table ID 1 選択
				}
				else {
					uc_cmd[1] = 0x00;									// Table ID 0 選択
				}
				uc_len    = 2;
				
#ifdef	d_ENA_AUTODISCRI_MDP		// 120704 KA
				memcpy(&Gs_ENA_prm.s_adis_mdp.uc_tbl_adiscri[uc_id2][0][0], 
											&Guc_ENA_AutoDiscriTbl_RAM[uc_id2][0][0],
											d_Lcl_ENA_AUTODISCRITBL_TNUM * d_Lcl_ENA_AUTODISCRITBL_DATANUM_STORE);
#endif
			}
			else if(11 <= pstw->uc_wrtcount_rem && pstw->uc_wrtcount_rem <= 42){
				uc_cmd[0] = d_Lcl_ENA_SensorCMD_WriteAutoDiscriTbl;
				uc_id     = pstw->uc_wrtcount_rem - 11;					// 温度ステップ
				uc_cmd[1] = ((uc_id2 << 7) | uc_id);					// table ID, 温度 step
				
				puc = &Guc_ENA_AutoDiscriTbl_RAM[uc_id2][uc_id][0];
				uc_cmd[2] = (0x0f & (*puc++));							// 温度は 12bit値
				uc_cmd[3] = *puc++;
				uc_cmd[4] = (0x03 & ((*puc) >> 6));						// format 変換
				uc_cmd[5] = (0x03 & ((*puc) >> 4));
				uc_cmd[6] = (0x03 & ((*puc) >> 2));
				uc_cmd[7] = (0x03 & (*puc));
				puc++;
				
				for(i = 6; i < d_Lcl_ENA_AUTODISCRITBL_DATANUM; i++){
					uc_cmd[2 + i] = *puc++;
				}
				uc_len    = 23;
			}
			else if(pstw->uc_wrtcount_rem == 10){
				uc_cmd[0] = d_Lcl_ENA_SensorCMD_SelAutoDiscriTbl;
				
				// 選択テーブルを元に戻す
				// HK 値とコマンド制御値が異なるので注意
				if(uc_autodiscri_tblid == 2)	{ uc_cmd[1] = 1; }
				else							{ uc_cmd[1] = 0; }
				
				uc_len    = 2;
			}
			
			if(uc_cmd[0] != d_Lcl_ENA_SensorCMD_UNDEF){
				app_PiCmd(Gd_N_ENA, uc_cmd, uc_len);					// コマンド送信
			}
		
			pstw->uc_wrtcount_rem--;									// カウントダウン
			if(pstw->uc_wrtcount_rem == 0){
				pstw->uc_wrt_target &= (~0x0c);							// 処理終了フラグ
			}
		}
		else {
			pstw->uc_wrt_target &= (~0x2f);								// 処理終了フラグ
		}
	}
	
	
	if(! (pstw->uc_wrt_target | pstw->uc_wrt_target_mdis)){
		pstw->uc_endsts = TRUE;
	}
	
	return TRUE;
}


#ifdef	d_ENA_AUTODISCRI_MDP		// 120704 KA
int app02_ENA_DiscriChg_AutoMDP_toSensor(void)
{
	unsigned char uc_cmd[5];
	unsigned char *puc, uc;

	if(Gs_ENA_prm.s_adis_mdp.uc_wrtcount_rem == 0 || Gs_ENA_prm.s_adis_mdp.uc_wrtcount_rem > 19){
		Gs_ENA_prm.s_adis_mdp.uc_wrtcount_rem = 19;
	}
	
	puc = &Gs_ENA_prm.s_adis_mdp.uc_tbl_adiscri[Gs_ENA_prm.s_adis_mdp.uc_tblid][Gs_ENA_prm.s_adis_mdp.uc_curstep][2];
	
	uc = 19 - Gs_ENA_prm.s_adis_mdp.uc_wrtcount_rem;
	
	uc_cmd[0] = d_Lcl_ENA_SensorCMD_SetDiscri;
	uc_cmd[2] = 0;
	uc_cmd[3] = 0;
	uc_cmd[4] = 0;
			
	if(uc >= 11){		// STOP SECTOR
		uc_cmd[1] = *(puc + uc - 3);	// discri data
		uc_cmd[4] = ( 1 << (uc - 11) );
	}
	else if(uc >= 4){	// START SECTOR
		uc_cmd[1] = *(puc + uc - 3);	// discri data
		uc_cmd[3] = ( 1 << (uc - 4) );
	}
	else {				// START RING
		uc_cmd[1] = (0x03 & ( (*puc) >> (2 * (3 - uc))));	// discri data
		uc_cmd[2] = ( 1 << uc );
	}

	app_PiCmd(Gd_N_ENA, uc_cmd, 5);				// コマンド送信

	Gs_ENA_prm.s_adis_mdp.uc_wrtcount_rem--;

	if(Gs_ENA_prm.s_adis_mdp.uc_wrtcount_rem == 0){
		Gs_ENA_prm.s_adis_mdp.uc_wrt_target = FALSE;	// 処理終了フラグ
	}
		
	return TRUE;
}
#endif