/******************************************************************************* * モジュール名称 ：APP04 Mission TLM (L&M) PI tasks * * モジュールラベル ：app04_PIs * * タスク区分 ：Application-03 ENA task for Mission TLM (L&M) * * 機能 ： * * コーリングシーケンス：void app03_ENA * * 引数 ：なし * * 戻り値 ：なし * * 使用上の注意 ：グローバル変数はアプリケーション０１でまとめて初期化 * * エラー処理 ：なし * * 作成日・作成者 ：2011/06/18 Y.K. * * 注意 ： EDIT権限は、MPPE/ENA組 * 2011.07.28 *******************************************************************************/ #include "app_MPPE-ENA.h" // *** Macro - Local *** #ifdef DUMMY_DATA_GEN char app04_ENA_dummydatagen(unsigned char *pucbuf); #endif void app04_ENA( unsigned int ui_app04Cnt, unsigned int ui_sunpulseTI ) { // === BLOCK read === int i_numNewBlock; // Num of blocks with new data M_T_BLOCK_INFO t_blockInfo; // unsigned int ui_createTime Block 生成開始時衛星時刻(1LSB=1,953ms) // int i_replyNum Block 登録Read-Reply個数 // char c_invalidFlg Block 内データ異常 [0:異常なし 1:異常あり] // unsigned int ui_blockIndex LongBuffer/ShortBuffer 内Block特定番号 (先頭Block:0) M_T_TIME_INFO t_timeInfo; // unsigned int ui_currentTime2; ：衛星時刻(1LSB=31.25ms) unsigned int uit, uidt; unsigned int ui_load0; // 基準時刻? int i, j, k; int i_flag; unsigned char *puc; unsigned char uc, uc_flg_tlmout; #ifdef d_ENA_TIMEMEASUREMENT M_T_TIME_INFO t_timeInfo_tmp; #endif #ifdef d_ENA_TIMEMEASUREMENT if(Gs_ENA_prm.uc_timeas_flg){ Gs_ENA_prm.ui_ti1[0] = Gs_ENA_prm.ui_ti0[0]; Gs_ENA_prm.ui_ti1[1] = Gs_ENA_prm.ui_ti0[1]; Gs_ENA_prm.ui_ti1[2] = Gs_ENA_prm.ui_ti0[2]; Gs_ENA_prm.ui_ti1[3] = Gs_ENA_prm.ui_ti0[3]; } Gs_ENA_prm.uc_timeas_flg = FALSE; dpu_getTime( &t_timeInfo_tmp ); Gs_ENA_prm.ui_ti0[0] = t_timeInfo_tmp.ui_currentTime; #endif #ifdef d_ENA_LOCAL_EMU // fprintf(stderr, "TI %04x %04x %04x %04x\n", ui_sunpulseCnt, Gs_ENA_prm.ui_sunpulseCnt0, ui_sunpulseTI, Gs_ENA_prm.ui_sunpulseTI0); #endif #ifdef d_ENA_DEBUG_SUNPULSE Gs_ENA_prm.ui_sunpulseTI = ui_sunpulseTI; Gs_ENA_prm.ui_spinperiod = app_ti_spinRate(ui_sunpulseTI, Gd_N_ENA, &Gs_ENA_prm.ui_sunpulseCnt); #endif // スピン周期の計算 // if(Gs_ENA_prm.ui_sunpulseCnt0 < ui_sunpulseCnt){ // if(ui_sunpulseTI < Gs_ENA_prm.ui_sunpulseTI0){ // uit = (0xffffffff - Gs_ENA_prm.ui_sunpulseTI0) + 1 + ui_sunpulseTI; // } // else { // uit = ui_sunpulseTI - Gs_ENA_prm.ui_sunpulseTI0; // } // Gs_ENA_prm.ui_spinperiod = uit / (ui_sunpulseCnt - Gs_ENA_prm.ui_sunpulseCnt0); // } // if(ui_sunpulseCnt != Gs_ENA_prm.ui_sunpulseCnt0){ // Gs_ENA_prm.ui_sunpulseTI0 = ui_sunpulseTI; // Gs_ENA_prm.ui_sunpulseCnt0 = ui_sunpulseCnt; // } #ifdef d_ENA_LOCAL_EMU // fprintf(stderr, "spinperiod %04x\n", Gs_ENA_prm.ui_spinperiod); #endif // ------------------------------------------- // -- Set at the oldest non-processed block -- // ------------------------------------------- // Newest Block i_numNewBlock = app_SetNonProcBlock( Gd_N_ENA, 0, // [INPUT] NodeID = Gd_N_MSAS, Data ID = 0 0, // [INPUT] Buffer ID = 0 (LONG) // [ENA does not use Short-buffer.] Gui_TLMm_blockTime[Gd_N_ENA],// [INPUT] TI of Processed Block &t_blockInfo); // [OUTPUT] Block Info // (return) >0:Num of blocks, <=0:No data (error) Gs_ENA_prm.s_mdb.us_numNewBlock = (unsigned short)i_numNewBlock; // mission data buffer (long buffer) のクリア要求への対応 ------- if(Gs_ENA_prm.s_mdb.uc_clear_req == TRUE){ Gs_ENA_prm.s_mdb.uc_clear_req = FALSE; // mission data buffer (long buffer) のクリア if(i_numNewBlock >= 1){ app_ReleaseBlock(Gd_N_ENA, 0, 0, i_numNewBlock); i_numNewBlock = app_SetNonProcBlock( Gd_N_ENA, 0, // [INPUT] NodeID = Gd_N_MSAS, Data ID = 0 0, // [INPUT] Buffer ID = 0 (LONG) // [ENA does not use Short-buffer.] Gui_TLMm_blockTime[Gd_N_ENA],// [INPUT] TI of Processed Block &t_blockInfo); // [OUTPUT] Block Info // (return) >0:Num of blocks, <=0:No data (error) } } // -------------------------------------------------------------- if ( i_numNewBlock < 1 ) { Gui_TLMm_blockTime[Gd_N_ENA] = t_blockInfo.ui_createTime; // === shift to newest data for SKIP === return; } // --------------------- // -- Read Block data -- // --------------------- // // sunpulse 時間が更新されてから current time が更新されるまでの間に時刻取得がなされると // sunpulse 時刻の方が後になる場合がある。これを防ぐ。 (120311) while (TRUE){ i_flag = dpu_getTime(&t_timeInfo ); if ( t_timeInfo.ui_sunpulseTime <= t_timeInfo.ui_currentTime ) break; } ui_load0 = t_timeInfo.ui_currentTime2; // トリガ判定データのクリア if(Gs_ENA_prm.uc_trg_clear_req){ Gs_ENA_prm.uc_trg_clear_req = FALSE; Gs_ENA_prm.uc_trg_curpos = 0; Gs_ENA_prm.uc_trgset_flagset = FALSE; Gs_ENA_prm.ui_trgset_ti = 0; Gs_ENA_prm.ui_trgset_precnt = 0; Gs_ENA_prm.ui_trgset_postcnt = 0; Gs_ENA_prm.uc_trg_ena = Gs_ENA_prm.uc_trg_ena0; Gs_ENA_prm.uc_trg_acqmode = Gs_ENA_prm.uc_trg_acqmode0; Gs_ENA_prm.uc_trg_prenum = Gs_ENA_prm.uc_trg_prenum0; Gs_ENA_prm.uc_trg_postnum = Gs_ENA_prm.uc_trg_postnum0; Gs_ENA_prm.uc_trg_precnt10 = Gs_ENA_prm.uc_trg_precnt00; Gs_ENA_prm.uc_trg_precnt11 = Gs_ENA_prm.uc_trg_precnt01; Gs_ENA_prm.ui_trg_precnt = (((unsigned int)Gs_ENA_prm.uc_trg_precnt10) << Gs_ENA_prm.uc_trg_precnt11); Gs_ENA_prm.uc_trg_postcnt10 = Gs_ENA_prm.uc_trg_postcnt00; Gs_ENA_prm.uc_trg_postcnt11 = Gs_ENA_prm.uc_trg_postcnt01; Gs_ENA_prm.ui_trg_postcnt = (((unsigned int)Gs_ENA_prm.uc_trg_postcnt10) << Gs_ENA_prm.uc_trg_postcnt11); for(i = 0; i < 2 * d_Lcl_ENA_TRGDATA_NUM; i++){ Gs_ENA_prm.ui_trg_ti[i] = 0; Gs_ENA_prm.ui_trg_totalccnt[i] = d_Lcl_ENA_TRGDATA_INVALID; } } if(Gs_ENA_prm.uc_ProcessMode == d_Lcl_ENA_MODE_DUMP){ if(0x0000 != (d_Lcl_ENA_DUMP_TGTIDMASK & Gs_ENA_prm.s_dmp.us_dump_target)){ app04_ENA_DumpTbl(&t_timeInfo); // テーブルダンプ } } for (i = 0; i < i_numNewBlock; i++) { uc_flg_tlmout = FALSE; // if(i == i_numNewBlock - 1) { if ( t_blockInfo.ui_createTime > Gui_TLMm_blockTime[Gd_N_ENA] && // NEW data t_blockInfo.i_replyNum > 0 && // Data available t_blockInfo.c_invalidFlg == 0 ) { // Data correct for (j = 0; j < 16; j++) { // ENA は 16 packets/block (see app_common.h) // ***MSASI: 32 packet / block // RMAP-read-header ?byte (12B?) // Contents 3072B (384B x 8) // Contents in slot B0-3 TI0 highest->lowest (LSB:1.925ms) // B4-5 TI1 high ->low (LSB:1.925ms) <<>> // **** 上記で TI = TI0 + TI1 なのはなぜ?? // B6: mode(packetID) // B7: slotID // ************************** // **** Packet read: ALL **** // ************************** i_flag = app_GetPacket( 4, // [INPUT] App-No:4 Gd_N_ENA, 0, // [INPUT] NodeID = Gd_N_ENA, Data ID = 0 0, // [INPUT] Buffer ID = 0 (LONG) [ENA does not use Short-buffer.] &t_blockInfo, // [INPUT] Block Info j, // [INPUT] Packet No (先頭:0) 0, // [INPUT] OFFSET読出開始番地(8の倍数） Gd_Pac_ENA, // [INPUT] 読出データ数: B8 - B23 G04uc_data ); // [OUTPUT] 1 Block Data - copied if ( i_flag ) continue; Gui_TLMm_blockTime[Gd_N_ENA] = t_blockInfo.ui_createTime; // !!! Successfuly Processed !!! // TI = TI0 + TI1 // TI0: Sunpulse 受信時刻 [1.953ms] (32bit) // TI1: TI0 からの経過時間 [1.953ms] (16bit) // Gs_ENA_prm.ui_dataTi0 = ((unsigned int)(G04uc_data[4]) << 24) + // ((unsigned int)(G04uc_data[5]) << 16) + // ((unsigned int)(G04uc_data[6]) << 8) + // ((unsigned int)(G04uc_data[7]) ); // Gs_ENA_prm.ui_dataTi1 = ((unsigned int)(G04uc_data[8]) << 8) + // ((unsigned int)(G04uc_data[9]) ); #ifdef d_ENA_LOCAL_EMU // 120416 Gs_ENA_prm.ui_dataTi0 = ((unsigned int)(G04uc_data[0xc]) << 24) + ((unsigned int)(G04uc_data[0xd]) << 16) + ((unsigned int)(G04uc_data[0xe]) << 8) + ((unsigned int)(G04uc_data[0xf]) ); #else #ifdef d_ENA_ATTEMPT_TO_SMALLSIZE2 // 120416 memcpy((unsigned char *)&Gs_ENA_prm.ui_dataTi0, &G04uc_data[0xc], 4); #else Gs_ENA_prm.ui_dataTi0 = ((unsigned int)(G04uc_data[0xc]) << 24) + ((unsigned int)(G04uc_data[0xd]) << 16) + ((unsigned int)(G04uc_data[0xe]) << 8) + ((unsigned int)(G04uc_data[0xf]) ); #endif #endif Gs_ENA_prm.ui_dataTi1 = ((unsigned int)(G04uc_data[0x10]) << 8) + ((unsigned int)(G04uc_data[0x11]) ); Gs_ENA_prm.ui_dataTi = Gs_ENA_prm.ui_dataTi0 + Gs_ENA_prm.ui_dataTi1; if(Gs_ENA_prm.uc_ProcessMode != d_Lcl_ENA_MODE_DUMP && Gs_ENA_prm.uc_ProcessMode != d_Lcl_ENA_MODE_IDLE){ #ifdef DUMMY_DATA_GEN app04_ENA_dummydatagen(G04uc_data + 0xc); #endif // 先頭スロットがあるかどうか調べる。 // 先頭スロット = Gs_ENA_prm.uc_startP * 4 <-- 0x22 (無効データ時) にはならない。 // // engineering mode (センサーモード) ではすべてのスロットに有効データが入るわけではない。 // 無効データ時には センサーモード、スロット ID とも 0 となる。 // ここではスロット 8n+0 -- 8n+7 の間に一つデータがあるとしている。 // non-process mode でセンサーモードが engineering mode の時には他モードと異なる動作となる。 // PROCESS MODE SET コマンド発行時に CP10 b[2:0] を 4, CP14 y[4:0] を 0に設定すること。 // また、us_IntervalSpin 設定 (CP10 a[3:0]) は正しく動作しない。slotID = 0 となった場合に // 1スピンしたと数えてしまうため。 if(Gs_ENA_prm.uc_ProcessMode == d_Lcl_ENA_MODE_IFE_ENGINEERING){ for(k = 0; k < 8; k++){ if( d_Lcl_ENA_SENSORMODE_ENG == *(G04uc_data + 0xc + 0x6 + k * d_Lcl_ENA_SIZE_SLOT) ){ uc = *(G04uc_data + 0xc + 0x7 + k * d_Lcl_ENA_SIZE_SLOT); // slotID if(uc < 4 * Gs_ENA_prm.uc_startP){ if(uc + d_Lcl_ENA_SLOT_NUM < 4 * Gs_ENA_prm.uc_startP + 8){ break; } } else { if(uc < 4 * Gs_ENA_prm.uc_startP + 8){ break; } } } } } else { for(k = 0; k < 8; k++){ if( Gs_ENA_prm.uc_startP * 4 == *(G04uc_data + 0xc + 0x7 + k * d_Lcl_ENA_SIZE_SLOT) ){ // slotID break; } } } if(Gs_ENA_prm.uc_ProcessMode == d_Lcl_ENA_MODE_IFE_ENGINEERING || Gs_ENA_prm.uc_ProcessMode == d_Lcl_ENA_MODE_IFE_TABLEREAD || Gs_ENA_prm.uc_ProcessMode == d_Lcl_ENA_MODE_NONPROCESS){ if(Gs_ENA_prm.uc_waitSlotID0 == FALSE && Gs_ENA_prm.s_npm.uc_dataprocspinflg){ // slotID 0 - k-1 までの処理 i_flag = app04_ENA_DataProcess1(G04uc_data + 0xc, k, Gs_ENA_prm.s_npm.uc_datatopflg); if(i_flag && Gs_ENA_prm.s_npm.us_pcktsize > 0){ Gs_ENA_prm.s_npm.uc_datatopflg = FALSE; Gs_ENA_prm.s_npm.us_bufoffset += Gs_ENA_prm.s_npm.us_pcktsize; } } // 先頭の slotID が検出された場合 if(k < 8){ #ifdef d_ENA_DEBUG_SUNPULSE // ******************************* Gs_ENA_prm.ui_spinperiod = app_ti_spinRate(ui_sunpulseTI, Gd_N_ENA, &Gs_ENA_prm.ui_sunpulseCnt); if(Gs_ENA_prm.ui_spinperiod != 0){ puc = G04uc_data + 0xc + k * d_Lcl_ENA_SIZE_SLOT; uit = (((unsigned int)puc[0]) << 24) + (((unsigned int)puc[1]) << 16) + (((unsigned int)puc[2]) << 8) + ( (unsigned int)puc[3]); uit += (((unsigned int)puc[4]) << 8) + ( (unsigned int)puc[5]); if(ui_sunpulseTI < uit){ uidt = (0xffffffff - uit) + 1 + ui_sunpulseTI; } else { uidt = ui_sunpulseTI - uit; } Gs_ENA_prm.ui_data_sunpulseCnt = Gs_ENA_prm.ui_sunpulseCnt - ( (uidt + (Gs_ENA_prm.ui_spinperiod >> 2) ) / Gs_ENA_prm.ui_spinperiod ); Gs_ENA_prm.ui_sensorTI = uit; Gs_ENA_prm.uidt = uidt; Gs_ENA_prm.uitmp = (uidt + (Gs_ENA_prm.ui_spinperiod >> 2) ) / Gs_ENA_prm.ui_spinperiod; } #endif // ******************************************************** if(Gs_ENA_prm.uc_waitSlotID0){ // モード変更時には前のモードのデータが読みだされる可能性がある。 // これは、ブロッククリアは app02 で行われるので、時間遅れがあり得るため。 // また、ENG モード時にモード変更すると、オールゼロのデータが読みだされる可能性がある。 // non-process モード時でセンサーが ENG モードの時に異なる動作をすることになる。 uc = *(G04uc_data + 0xc + 0x6 + k * d_Lcl_ENA_SIZE_SLOT); if( ( Gs_ENA_prm.uc_ProcessMode == d_Lcl_ENA_MODE_IFE_ENGINEERING && uc == d_Lcl_ENA_SENSORMODE_ENG ) || ( Gs_ENA_prm.uc_ProcessMode == d_Lcl_ENA_MODE_IFE_TABLEREAD && uc == d_Lcl_ENA_SENSORMODE_SVREAD ) || ( Gs_ENA_prm.uc_ProcessMode == d_Lcl_ENA_MODE_NONPROCESS ) ) { Gs_ENA_prm.uc_waitSlotID0 = FALSE; Gs_ENA_prm.s_npm.us_IntervalSpin_cur = 0; Gs_ENA_prm.s_npm.uc_dataprocspinflg = TRUE; Gs_ENA_prm.s_npm.uc_datatopflg = TRUE; Gs_ENA_prm.s_npm.us_bufoffset = 0; #ifdef d_ENA_DEBUG_ENGMODE Gs_ENA_prm.ui_deng_ctr = 0; #endif } } else { if(Gs_ENA_prm.s_npm.us_bufoffset != 0){ app04_ENA_tlmout((unsigned char *)&Gui_ENA_AccumMat[0], d_Lcl_ENA_ACCUMTBL_HEADA_SIZE + Gs_ENA_prm.s_npm.us_bufoffset, TRUE, // 観測データ TRUE); // 新データ uc_flg_tlmout = TRUE; Gs_ENA_prm.s_npm.us_bufoffset = 0; #ifdef d_ENA_DEBUG_ENGMODE Gs_ENA_prm.ui_deng_ctr = 0; #endif } Gs_ENA_prm.s_npm.us_IntervalSpin_cur++; if(Gs_ENA_prm.s_npm.us_IntervalSpin_cur < Gs_ENA_prm.s_npm.us_IntervalSpin){ Gs_ENA_prm.s_npm.uc_dataprocspinflg = FALSE; } else { Gs_ENA_prm.s_npm.uc_dataprocspinflg = TRUE; Gs_ENA_prm.s_npm.us_IntervalSpin_cur = 0; Gs_ENA_prm.s_npm.uc_datatopflg = TRUE; } } } if(Gs_ENA_prm.uc_waitSlotID0 == FALSE && Gs_ENA_prm.s_npm.uc_dataprocspinflg){ // slotID k - 7 までの処理 i_flag = app04_ENA_DataProcess1(G04uc_data + 0xc + k * d_Lcl_ENA_SIZE_SLOT, 8 - k, Gs_ENA_prm.s_npm.uc_datatopflg); if(i_flag && Gs_ENA_prm.s_npm.us_pcktsize > 0){ Gs_ENA_prm.s_npm.uc_datatopflg = FALSE; Gs_ENA_prm.s_npm.us_bufoffset += Gs_ENA_prm.s_npm.us_pcktsize; } } } else { // 頭出し if(k < 8){ if(Gs_ENA_prm.uc_waitSlotID0){ // データをスピン周期で重ね合わせる際、sunpulseCnt を使って他機器と同期がとれるようにする。 // 観測データ取得時のサンパルス TI が共通関数群内に保存されているとは限らないので // sunpulseCnt は ui_sunpulseTI 時の周期から推定する。 Gs_ENA_prm.ui_spinperiod = app_ti_spinRate(ui_sunpulseTI, Gd_N_ENA, &Gs_ENA_prm.ui_sunpulseCnt); if(Gs_ENA_prm.ui_spinperiod != 0){ puc = G04uc_data + 0xc + k * d_Lcl_ENA_SIZE_SLOT; #ifdef d_ENA_LOCAL_EMU // 120416 uit = (((unsigned int)puc[0]) << 24) + (((unsigned int)puc[1]) << 16) + (((unsigned int)puc[2]) << 8) + ( (unsigned int)puc[3]); #else #ifdef d_ENA_ATTEMPT_TO_SMALLSIZE2 // 120416 memcpy((unsigned char *)&uit, puc, 4); #else uit = (((unsigned int)puc[0]) << 24) + (((unsigned int)puc[1]) << 16) + (((unsigned int)puc[2]) << 8) + ( (unsigned int)puc[3]); #endif #endif uit += (((unsigned int)puc[4]) << 8) + ( (unsigned int)puc[5]); if(ui_sunpulseTI < uit){ uidt = (0xffffffff - uit) + 1 + ui_sunpulseTI; } else { uidt = ui_sunpulseTI - uit; } Gs_ENA_prm.ui_data_sunpulseCnt = Gs_ENA_prm.ui_sunpulseCnt - ( (uidt + (Gs_ENA_prm.ui_spinperiod >> 2) ) / Gs_ENA_prm.ui_spinperiod ); #ifdef d_ENA_DEBUG_SUNPULSE Gs_ENA_prm.ui_sensorTI = uit; Gs_ENA_prm.uidt = uidt; Gs_ENA_prm.uitmp = (uidt + (Gs_ENA_prm.ui_spinperiod >> 2) ) / Gs_ENA_prm.ui_spinperiod; #endif // モード変更時には前のモードのデータが読みだされる可能性がある。 // これは、ブロッククリアは app02 で行われるので、時間遅れがあり得るため。 // また、ENG モード時にモード変更すると、オールゼロのデータが読みだされる可能性がある。 // coincidence モードのパケット ID が 0x00 であるため、間違えて coincidence モードと // 思ってしまわないように uit != 0 を条件にする。 if( (uit != 0) && (0 == (Gs_ENA_prm.ui_data_sunpulseCnt % Gs_ENA_prm.us_numaddSpin))){ uc = *(G04uc_data + 0xc + 0x6 + k * d_Lcl_ENA_SIZE_SLOT); if( ( Gs_ENA_prm.uc_ProcessMode == d_Lcl_ENA_MODE_ACCUMMASS && uc == d_Lcl_ENA_SENSORMODE_COINCI ) || ( Gs_ENA_prm.uc_ProcessMode == d_Lcl_ENA_MODE_ACCUMCNT && uc == d_Lcl_ENA_SENSORMODE_COUNT ) || ( Gs_ENA_prm.uc_ProcessMode == d_Lcl_ENA_MODE_ACCUMTOF && uc == d_Lcl_ENA_SENSORMODE_COINCI ) ){ Gs_ENA_prm.uc_waitSlotID0 = FALSE; Gs_ENA_prm.us_numaddSpin_cur = 0; Gs_ENA_prm.uc_datatopflg = TRUE; } } #ifdef d_ENA_LOCAL_EMU // fprintf(stderr, "dti %x %x %04x %04x %04x %04x %04x %04x %04x\n", Gs_ENA_prm.uc_ProcessMode, Gs_ENA_prm.uc_waitSlotID0, uit, uidt, Gs_ENA_prm.ui_data_sunpulseCnt, Gs_ENA_prm.ui_sunpulseCnt, ui_sunpulseTI, Gs_ENA_prm.ui_spinperiod, Gs_ENA_prm.us_numaddSpin); #endif } } else { if(!Gs_ENA_prm.uc_datatopflg){ Gs_ENA_prm.us_numaddSpin_cur++; } if(app04_ENA_DataProcess1(G04uc_data + 0xc, k, Gs_ENA_prm.uc_datatopflg )){ Gs_ENA_prm.uc_datatopflg = FALSE; } if(Gs_ENA_prm.us_numaddSpin_cur >= Gs_ENA_prm.us_numaddSpin){ Gs_ENA_prm.us_numaddSpin_cur = 0; Gs_ENA_prm.uc_datatopflg = TRUE; // app04_ENA_tlmout((unsigned int *)(G04uc_data + 0xc), 0x100); #ifdef d_ENA_TIMEMEASUREMENT Gs_ENA_prm.uc_timeas_flg = TRUE; dpu_getTime( &t_timeInfo_tmp ); Gs_ENA_prm.ui_ti0[2] = t_timeInfo_tmp.ui_currentTime; #endif switch (Gs_ENA_prm.uc_ProcessMode){ // // TODO: 高圧の初期オンモード時は高圧ステータス (on/off, ena/dif, tgt, cont, mon) + カウンタ (start sect 7, start ring 4, stop sect 8) // としたミッションパケットを生成すること // case d_Lcl_ENA_MODE_ACCUMMASS: #ifdef d_ENA_LOCAL_EMU //fprintf(stderr, "app04_ENA_acm0 %d\n", j); //fprintf(stdout, "AM TL calc0 %x calc1 %x numE %x numP %x numP0 %x numC %x numM %x\n", // Gs_ENA_prm.uc_numE * Gs_ENA_prm.uc_numP * ( Gs_ENA_prm.uc_numC * Gs_ENA_prm.uc_numM + 1 ), // Gs_ENA_prm.uc_numE * Gs_ENA_prm.uc_numP * d_Lcl_ENA_COINCI_CNTNUM, // Gs_ENA_prm.uc_numE, Gs_ENA_prm.uc_numP, Gs_ENA_prm.uc_numP0, Gs_ENA_prm.uc_numC, Gs_ENA_prm.uc_numM); #endif // coincidence data 部 // numE * numP * numC * numM + numE * numP: numE * numP は invalid TOF 用のカウンタ app04_ENA_Lin2Log(Gui_ENA_AccumMat_mass, (unsigned char *)Gui_ENA_AccumMat_mass, 4 * Gs_ENA_prm.uc_numP * Gs_ENA_prm.uc_numE * ( Gs_ENA_prm.uc_numC * Gs_ENA_prm.uc_numM + 1 ), Gs_ENA_prm.uc_CntDepth, Gs_ENA_prm.ui_CntOffset); // カウンタ部 (ヘッダ部も考慮している) puc = ((unsigned char *)&Gui_ENA_AccumMat[0]) + d_Lcl_ENA_ACCUMTBL_HEADA_SIZE + Gs_ENA_prm.uc_numP * Gs_ENA_prm.uc_numE * ( Gs_ENA_prm.uc_numC * Gs_ENA_prm.uc_numM + 1 ); // カウンタ部 app04_ENA_Lin2Log(Gui_ENA_AccumMat_mass_scale, puc, 4 * Gs_ENA_prm.uc_numP * Gs_ENA_prm.uc_numE * d_Lcl_ENA_COINCI_CNTNUM, Gs_ENA_prm.uc_CntDepth, Gs_ENA_prm.ui_CntOffset); app04_ENA_tlmout((unsigned char *)&Gui_ENA_AccumMat[0], d_Lcl_ENA_ACCUMTBL_HEADA_SIZE + Gs_ENA_prm.uc_numP * Gs_ENA_prm.uc_numE * ( Gs_ENA_prm.uc_numC * Gs_ENA_prm.uc_numM + 1 ) + Gs_ENA_prm.uc_numP * Gs_ENA_prm.uc_numE * d_Lcl_ENA_COINCI_CNTNUM, TRUE, // 観測データ TRUE); // 新データ uc_flg_tlmout = TRUE; break; case d_Lcl_ENA_MODE_ACCUMCNT: #ifdef d_ENA_LOCAL_EMU //fprintf(stderr, "app04_ENA_acnt0 %d\n", j); #endif // カウンタ部 app04_ENA_Lin2Log(Gui_ENA_AccumMat_cnt_scale, (unsigned char *)Gui_ENA_AccumMat_cnt_scale, 4 * Gs_ENA_prm.uc_numP * Gs_ENA_prm.uc_numE * d_Lcl_ENA_COUNT_CNTNUM, Gs_ENA_prm.uc_CntDepth, Gs_ENA_prm.ui_CntOffset); app04_ENA_tlmout((unsigned char *)&Gui_ENA_AccumMat[0], d_Lcl_ENA_ACCUMTBL_HEADA_SIZE + Gs_ENA_prm.uc_numP * Gs_ENA_prm.uc_numE * d_Lcl_ENA_COUNT_CNTNUM, TRUE, // 観測データ TRUE); // 新データ uc_flg_tlmout = TRUE; break; case d_Lcl_ENA_MODE_ACCUMTOF: // // TODO: Non-coincidence event data collection に対応すること (section 9.9.1 of SICD) // #ifdef d_ENA_LOCAL_EMU //fprintf(stderr, "app04_ENA_atof0 %d\n", j); #endif // TOF data 部 app04_ENA_Lin2Log(Gui_ENA_AccumMat_tof, (unsigned char *)Gui_ENA_AccumMat_tof, 4 * Gs_ENA_prm.uc_numE * Gs_ENA_prm.us_numTOF, Gs_ENA_prm.uc_CntDepth, Gs_ENA_prm.ui_CntOffset); // カウンタ部 (ヘッダ部も考慮している) puc = ((unsigned char *)&Gui_ENA_AccumMat[0]) + d_Lcl_ENA_ACCUMTBL_HEADA_SIZE + Gs_ENA_prm.uc_numE * Gs_ENA_prm.us_numTOF; app04_ENA_Lin2Log(Gui_ENA_AccumMat_tof_scale, puc, 4 * Gs_ENA_prm.uc_numE * d_Lcl_ENA_COINCI_CNTNUM, Gs_ENA_prm.uc_CntDepth, Gs_ENA_prm.ui_CntOffset); app04_ENA_tlmout((unsigned char *)&Gui_ENA_AccumMat[0], d_Lcl_ENA_ACCUMTBL_HEADA_SIZE + Gs_ENA_prm.uc_numE * Gs_ENA_prm.us_numTOF + Gs_ENA_prm.uc_numE * d_Lcl_ENA_COINCI_CNTNUM, TRUE, // 観測データ TRUE); // 新データ uc_flg_tlmout = TRUE; break; } #ifdef d_ENA_TIMEMEASUREMENT dpu_getTime( &t_timeInfo_tmp ); Gs_ENA_prm.ui_ti0[3] = t_timeInfo_tmp.ui_currentTime; #endif } } if(!Gs_ENA_prm.uc_waitSlotID0){ #ifdef d_ENA_LOCAL_EMU //fprintf(stderr, "app04_ENA_atop0 %d\n", j); #endif if(app04_ENA_DataProcess1(G04uc_data + 0xc + k * d_Lcl_ENA_SIZE_SLOT, 8 - k, Gs_ENA_prm.uc_datatopflg) ){ Gs_ENA_prm.uc_datatopflg = FALSE; #ifdef d_ENA_LOCAL_EMU //fprintf(stderr, "app04_ENA_atop1 %d\n", j); #endif } } } else { if(!Gs_ENA_prm.uc_waitSlotID0){ app04_ENA_DataProcess1(G04uc_data + 0xc, 8, FALSE ); } } } } } } // ================================================================== // app_ReleaseBlock // **************************************************************** // ***FUNC*** 古い順から「i_blockCnt」個のＢｌｏｃｋを削除 // **************************************************************** // [INPUT] unsigned char uc_nodeId Node-ID // unsigned char uc_dataId Data-ID // int i_bufId Buffer-ID // int i_blockCnt Num of released blocks // [return]int 0:nrm others:error // ================================================================== app_ReleaseBlock(Gd_N_ENA, 0, 0, 1); // } // 今回の本サブルーチンコール時にデータレコーダに伝送しなかった場合で、 // データレコーダに伝送されずに残っているデータがある場合に伝送する。 if(uc_flg_tlmout == FALSE){ app04_ENA_tlmout(NULL, 0, TRUE, FALSE); uc_flg_tlmout = TRUE; } // i_flag = dpu_getTime( &t_timeInfo ); if ( t_timeInfo.ui_currentTime2 - ui_load0 > 128 ) { break;} // ***TMP*** If "time-consumption > 4sec" once go-out // To next block i_flag = app_NextBlock( Gd_N_ENA, 0, // [INPUT] NodeID = Gd_N_MSAS, Data ID = 0 0, // [INPUT] Buffer ID = 0 (LONG) [ENA does not use Short-buffer.] &t_blockInfo); // [OUTPUT] Block Info if ( i_flag ) break; // no data } #ifdef d_ENA_TIMEMEASUREMENT dpu_getTime( &t_timeInfo_tmp ); Gs_ENA_prm.ui_ti0[1] = t_timeInfo_tmp.ui_currentTime; #endif return; } #ifdef DUMMY_DATA_GEN char app04_ENA_dummydatagen(unsigned char *pucbuf) // ダミー観測データの生成 { unsigned char *puc; int i, j; struct _s_ENA_param *psp; psp = &Gs_ENA_prm; switch (psp->uc_ProcessMode){ case d_Lcl_ENA_MODE_ACCUMMASS: for(i = 0; i < 8; i++){ puc = pucbuf + 0x8 + i * d_Lcl_ENA_SIZE_SLOT; for(j = 0; j < d_Lcl_ENA_COINCI_CNTNUM; j++){ // カウンタは 18個 *(unsigned int *)puc = i; puc += 4; } puc = pucbuf + 0x8 + 4 * d_Lcl_ENA_COINCI_CNTNUM + i * d_Lcl_ENA_SIZE_SLOT; for(j = 0; j < 10; j++){ // start ring 3bit, start sect 3bit, stop err flg 1bit, stop sect 3bit, tof 10bit *puc++ = 0x00; // 0, 0, 0, 0x010 *puc++ = 0x01; *puc++ = 0x00; // 0, 0, 0, 0x010 *puc++ = 0x00; *puc++ = 0x10; *puc++ = 0x24; // 1, 1, 1, 0x080 *puc++ = 0x48; *puc++ = 0x04; // 2, 2, 2, 0x100 *puc++ = 0x89; *puc++ = 0x00; } *puc++ = 0x00; *puc++ = 0x00; *puc++ = 0x00; } break; case d_Lcl_ENA_MODE_ACCUMCNT: break; case d_Lcl_ENA_MODE_ACCUMTOF: break; case d_Lcl_ENA_MODE_NONPROCESS: break; case d_Lcl_ENA_MODE_IDLE: break; } return TRUE; } #endif char app04_ENA_tlmout(unsigned char *pucinbuf, unsigned short len, unsigned char uc_mishkflg, unsigned char uc_newdata) // len: [byte] // uc_mishkflg: TRUE: ミッションデータ (HK 以外) // FALSE: ミッションデータとして出す HK データ // uc_newdata: TRUE: 新データの場合 (データレコーダに転送されずに残っているデータがある場合、新データは破棄される) // FALSE: 古いデータを出す場合 (データレコーダに転送されずに残っているデータがある場合、転送する) { unsigned char *puc, *puc2; unsigned short *pus; unsigned short us, us_tlm_pcktseqnum1; int i, ii; struct _s_ENA_OutMisTlm *ps_omt; if(uc_mishkflg == TRUE){ // 観測データ ps_omt = &Gs_ENA_prm.s_omt[d_Lcl_ENA_MISTLMOUTBUFID_MIS]; ps_omt->puc_outbuf = (unsigned char *)&Gui_ENA_MisTlmoutbuf[0]; } else { // ミッションパケットとして出す HK データ ps_omt = &Gs_ENA_prm.s_omt[d_Lcl_ENA_MISTLMOUTBUFID_HK]; ps_omt->puc_outbuf = (unsigned char *)&Gui_ENA_HK_Tlmoutbuf[0]; } if(uc_newdata == TRUE && ps_omt->uc_flg_bufempty == TRUE){ // テレメ出力バッファのリードポインタの初期化 ps_omt->us_rpt = 0; // パケットシーケンスカウンタのインクリメント // 1 パケットが d_Lcl_ENA_MISSION_PCKT_SIZE_MAX より大きい場合は分割されるが、 // その際は同一のシーケンスナンバーとなる (別のシーケンスカウンタがインクリメントされる)。 Gs_ENA_prm.us_tlm_pcktseqnum++; us_tlm_pcktseqnum1 = Gs_ENA_prm.us_tlm_pcktseqnum; // パケット長を格納する。 *(pucinbuf + 2) = (0xff & (len >> 8)); *(pucinbuf + 3) = (0xff & len); #ifdef d_ENA_TIMEMEASUREMENT *(pucinbuf + 0xc) = (0xff & (Gs_ENA_prm.ui_ti1[0] >> 24)); *(pucinbuf + 0xd) = (0xff & (Gs_ENA_prm.ui_ti1[0] >> 16)); *(pucinbuf + 0xe) = (0xff & (Gs_ENA_prm.ui_ti1[0] >> 8)); *(pucinbuf + 0xf) = (0xff & Gs_ENA_prm.ui_ti1[0]); *(pucinbuf + 0x10) = (0xff & (Gs_ENA_prm.ui_ti1[1] >> 24)); *(pucinbuf + 0x11) = (0xff & (Gs_ENA_prm.ui_ti1[1] >> 16)); *(pucinbuf + 0x12) = (0xff & (Gs_ENA_prm.ui_ti1[1] >> 8)); *(pucinbuf + 0x13) = (0xff & Gs_ENA_prm.ui_ti1[1]); *(pucinbuf + 0x14) = (0xff & (Gs_ENA_prm.ui_ti1[2] >> 24)); *(pucinbuf + 0x15) = (0xff & (Gs_ENA_prm.ui_ti1[2] >> 16)); *(pucinbuf + 0x16) = (0xff & (Gs_ENA_prm.ui_ti1[2] >> 8)); *(pucinbuf + 0x17) = (0xff & Gs_ENA_prm.ui_ti1[2]); *(pucinbuf + 0x18) = (0xff & (Gs_ENA_prm.ui_ti1[3] >> 24)); *(pucinbuf + 0x19) = (0xff & (Gs_ENA_prm.ui_ti1[3] >> 16)); *(pucinbuf + 0x1a) = (0xff & (Gs_ENA_prm.ui_ti1[3] >> 8)); *(pucinbuf + 0x1b) = (0xff & Gs_ENA_prm.ui_ti1[3]); #endif #ifdef d_ENA_DEBUG_MIAMSAMEAENA *(unsigned int *)(pucinbuf + 0x20) = Gst_MIA_ctrl.ui_eng_vmf; // app03_MIA calling time *(unsigned int *)(pucinbuf + 0x24) = Gst_MEA1_ctrl.ui_eng_vmf; // app03_MEA1 calling time *(unsigned int *)(pucinbuf + 0x28) = Gst_MEA2_ctrl.ui_eng_vmf; // app03_MEA2 calling time memcpy(pucinbuf + 0x2c, &Gst_MSA_cmd.uc_ans[0], 4); // app03_MSA calling time memcpy(pucinbuf + 0x30, &Gst_MIA_cmd.uc_ans[0], 4); // app05_MIA calling time memcpy(pucinbuf + 0x34, &Gst_MEA1_cmd.uc_ans[0], 4); // app05_MEA1 calling time memcpy(pucinbuf + 0x38, &Gst_MEA2_cmd.uc_ans[0], 4); // app05_MEA2 calling time memcpy(pucinbuf + 0x3c, &Gst_MSA_cmd.ui_tmp, 4); // app05_MSA calling time #endif #ifdef d_ENA_DEBUG_ENGMODE *(pucinbuf + 0xc) = (0xff & (Gs_ENA_prm.s_npm.us_pcktsize >> 8)); *(pucinbuf + 0xd) = (0xff & Gs_ENA_prm.s_npm.us_pcktsize); *(pucinbuf + 0xe) = (0xff & (Gs_ENA_prm.s_npm.us_bufoffset >> 8)); *(pucinbuf + 0xf) = (0xff & Gs_ENA_prm.s_npm.us_bufoffset); *(pucinbuf + 0x10) = (0xff & (Gs_ENA_prm.s_npm.us_numpckt_sent >> 8)); *(pucinbuf + 0x11) = (0xff & Gs_ENA_prm.s_npm.us_numpckt_sent); *(pucinbuf + 0x12) = (0xff & (Gs_ENA_prm.s_npm.us_numpckt_tgt >> 8)); *(pucinbuf + 0x13) = (0xff & Gs_ENA_prm.s_npm.us_numpckt_tgt); *(pucinbuf + 0x14) = (0xff & (Gs_ENA_prm.ui_deng_ctr >> 8)); *(pucinbuf + 0x15) = (0xff & Gs_ENA_prm.ui_deng_ctr); #endif #ifdef d_ENA_DEBUG_SUNPULSE *(pucinbuf + 0xc) = (0xff & (Gs_ENA_prm.ui_sunpulseTI >> 24)); *(pucinbuf + 0xd) = (0xff & (Gs_ENA_prm.ui_sunpulseTI >> 16)); *(pucinbuf + 0xe) = (0xff & (Gs_ENA_prm.ui_sunpulseTI >> 8)); *(pucinbuf + 0xf) = (0xff & Gs_ENA_prm.ui_sunpulseTI); *(pucinbuf + 0x10) = (0xff & (Gs_ENA_prm.ui_sunpulseCnt >> 24)); *(pucinbuf + 0x11) = (0xff & (Gs_ENA_prm.ui_sunpulseCnt >> 16)); *(pucinbuf + 0x12) = (0xff & (Gs_ENA_prm.ui_sunpulseCnt >> 8)); *(pucinbuf + 0x13) = (0xff & Gs_ENA_prm.ui_sunpulseCnt); *(pucinbuf + 0x14) = (0xff & (Gs_ENA_prm.ui_spinperiod >> 24)); *(pucinbuf + 0x15) = (0xff & (Gs_ENA_prm.ui_spinperiod >> 16)); *(pucinbuf + 0x16) = (0xff & (Gs_ENA_prm.ui_spinperiod >> 8)); *(pucinbuf + 0x17) = (0xff & Gs_ENA_prm.ui_spinperiod); *(pucinbuf + 0x18) = (0xff & (Gs_ENA_prm.ui_data_sunpulseCnt >> 24)); *(pucinbuf + 0x19) = (0xff & (Gs_ENA_prm.ui_data_sunpulseCnt >> 16)); *(pucinbuf + 0x1a) = (0xff & (Gs_ENA_prm.ui_data_sunpulseCnt >> 8)); *(pucinbuf + 0x1b) = (0xff & Gs_ENA_prm.ui_data_sunpulseCnt); *(pucinbuf + 0x1c) = (0xff & (Gs_ENA_prm.ui_sensorTI >> 24)); *(pucinbuf + 0x1d) = (0xff & (Gs_ENA_prm.ui_sensorTI >> 16)); *(pucinbuf + 0x1e) = (0xff & (Gs_ENA_prm.ui_sensorTI >> 8)); *(pucinbuf + 0x1f) = (0xff & Gs_ENA_prm.ui_sensorTI); *(pucinbuf + 0x20) = (0xff & (Gs_ENA_prm.uidt >> 24)); *(pucinbuf + 0x21) = (0xff & (Gs_ENA_prm.uidt >> 16)); *(pucinbuf + 0x22) = (0xff & (Gs_ENA_prm.uidt >> 8)); *(pucinbuf + 0x23) = (0xff & Gs_ENA_prm.uidt); *(pucinbuf + 0x24) = (0xff & (Gs_ENA_prm.uitmp >> 24)); *(pucinbuf + 0x25) = (0xff & (Gs_ENA_prm.uitmp >> 16)); *(pucinbuf + 0x26) = (0xff & (Gs_ENA_prm.uitmp >> 8)); *(pucinbuf + 0x27) = (0xff & Gs_ENA_prm.uitmp); #endif #ifdef d_ENA_DEBUG_TRG *(unsigned int *)(pucinbuf + 0xc) = Gs_ENA_prm.ui_trgset_ti; *(pucinbuf + 0x10) = Gs_ENA_prm.uc_trg_curpos; for(i = 0; i < 2 * d_Lcl_ENA_TRGDATA_NUM; i++){ *(unsigned int *)(pucinbuf + 0x14 + i * 4) = Gs_ENA_prm.ui_trg_ti[i]; } #endif if(Gs_ENA_prm.uc_CprsWayFlg == d_Lcl_ENA_CPRS_RICE){ ps_omt->uc_cmp = 3; // User defined pre-compression // ps_omt->uc_cmp = 0; // non compression ii = Rice_Compress(pucinbuf, ps_omt->puc_outbuf + 4, len, RICE_FMT_UINT8); ps_omt->us_pcktsize = ii + 4; ps_omt->uc_commentsize = 0x8; pus = (unsigned short *)&ps_omt->ui_comment[0]; *pus++ = LCLEMU_htons(d_Lcl_ENA_TLMID_CPRS); *pus++ = LCLEMU_htons(us_tlm_pcktseqnum1); // パケットシーケンスカウンタ *pus++ = 0; // 1 データパケットを送る際の TLM パケットのシーケンスカウンタ // *(unsigned short *)(Guc_ENA_TlmComment + 0x4) // 書き換わってゆくため、byte order を変えないほうがよい。 *pus++ = LCLEMU_htons(ps_omt->us_pcktsize); *(unsigned short *)ps_omt->puc_outbuf = LCLEMU_htons(len); // 圧縮前データサイズ *(unsigned short *)(ps_omt->puc_outbuf + 2) = LCLEMU_htons(ii); // 圧縮後データサイズ } else { ps_omt->uc_cmp = 0; // non compression ps_omt->us_pcktsize = len; // データレコーダへの伝送は何回かに分けて行う場合がある。 // 分けた場合にはデータ転送終了前に入力バッファに新しいデータが入る場合がある。 // このため、入力バッファをそのまま出力バッファとしては使えない。 puc = pucinbuf; puc2 = ps_omt->puc_outbuf; for(i = 0; i < len; i++){ *puc2++ = *puc++; } ps_omt->uc_commentsize = 0x8; pus = (unsigned short *)&ps_omt->ui_comment[0]; *pus++ = LCLEMU_htons(d_Lcl_ENA_TLMID_NCPRS); *pus++ = LCLEMU_htons(us_tlm_pcktseqnum1); // パケットシーケンスカウンタ *pus++ = 0; // 1 データパケットを送る際の TLM パケットのシーケンスカウンタ // *(unsigned short *)(Guc_ENA_TlmComment + 0x4) // 書き換わってゆくため、byte order を変えないほうがよい。 *pus++ = LCLEMU_htons(ps_omt->us_pcktsize); } ps_omt->uc_flg_bufempty = FALSE; } if(ps_omt->uc_flg_bufempty == FALSE){ us = ps_omt->us_pcktsize - ps_omt->us_rpt; if(us > d_Lcl_ENA_MISSION_PCKT_SIZE_MAX){ us = d_Lcl_ENA_MISSION_PCKT_SIZE_MAX; } ii = app_PutTlm( 4, // [INPUT] APP-NUM = 4 Gd_N_ENA, // [INPUT] Node-ID 0, // [INPUT] Data-ID Gd_N_ENA, // [INPUT] Header-ID (for PID-ID, CAT-ID setting) 2, // [INPUT]**DR-ID (for CAT-ID) [0:HK 1:OS 2:L 3:M 4-9:H(0-5)] ps_omt->uc_cmp, // [INPUT] Comp mode [0:non 1:JPEG-rev 2:Math 3-7:After-User-COMP] // 4: User defined pre-compression] Gs_ENA_prm.ui_pcktID & 0xff, // [INPUT]**Packet ID <<<< USER-DEF: 0x00- 0xFF >>>> Gs_ENA_prm.ui_dataTi, // [INPUT]**Data TI <<<< USER-DEF: 0x00000000-0xFFFFFFFF >>>> (unsigned char *)&ps_omt->ui_comment[0], // [INPUT] Comment <<<< USER-DEF: <128B >>>> ps_omt->uc_commentsize, // [INPUT] Comment - Size <<<< USER-DEF: <128B >>>> ps_omt->puc_outbuf + ps_omt->us_rpt, // [INPUT]**Data <<<< USER-DEF: <0x1E00 >>>> us ); // [INPUT]**Data - Size <<<< USER-DEF: <0x1E00 >>>> ps_omt->us_rpt += us; if(ps_omt->us_rpt >= ps_omt->us_pcktsize){ ps_omt->us_rpt = 0; ps_omt->uc_flg_bufempty = TRUE; } else { puc = (unsigned char *)&ps_omt->ui_comment[0]; ( *(unsigned short *)(puc + 4) )++; // 1 データパケットを送る際の TLM パケットのシーケンスナンバー ps_omt->uc_flg_bufempty = FALSE; } Gs_ENA_prm.ui_pcktID++; } return TRUE; } char app04_ENA_DataProcess1(unsigned char *pucinbuf, int islotnum, unsigned char uc_datatopflg0) { int i, j, i_len, i_trg_cnt; unsigned char *pucin, *puc, uc, uc_processflg = FALSE; unsigned char uc2, uc_trgflg = FALSE; unsigned short *pussrc; // unsigned short us; unsigned int *pui, *pui2, ui = 0, ui2 = 0, ui3 = 0, ui4 = 0; struct _s_ENA_param *psp; struct _s_ENA_processParam *pspcpm; psp = &Gs_ENA_prm; pspcpm = &Gs_ENA_prsprm; if(islotnum <= 0){ return FALSE; } // サイズが 0 の場合 if(islotnum > 8) { islotnum = 8; } // サイズが 8 (slotID 単位) 以上指定された場合 if(uc_datatopflg0){ if(psp->uc_ProcessMode == d_Lcl_ENA_MODE_ACCUMMASS || psp->uc_ProcessMode == d_Lcl_ENA_MODE_ACCUMCNT || psp->uc_ProcessMode == d_Lcl_ENA_MODE_ACCUMTOF ){ // バッファクリア pui = Gui_ENA_AccumMat; for(i = 0; i < d_Lcl_ENA_ACCUMTBL_SIZE / 4; i++){ *pui++ = 0; } } // mass accum モードでは mass データとカウンタデータの 2つがあり、それぞれが別に圧縮される。 // ただし、連続パケットになるので、ここで ID を書くことが mass データとカウンタデータ // の区別につながる。 //#ifdef d_ENA_ATTEMPT_TO_SMALLSIZE // // このソースの方が 32バイト大きくなる。 // // uc = psp->uc_ProcessMode; // if(uc == d_Lcl_ENA_MODE_ACCUMMASS){ // us = LCLEMU_htons(d_Lcl_ENA_MODEID_ACCUMMASS); // } // else if(uc == d_Lcl_ENA_MODE_ACCUMCNT){ // us = LCLEMU_htons(d_Lcl_ENA_MODEID_ACCUMCNT); // } // else if(uc == d_Lcl_ENA_MODE_ACCUMTOF){ // us = LCLEMU_htons(d_Lcl_ENA_MODEID_ACCUMTOF); // } // else if(uc == d_Lcl_ENA_MODE_IFE_ENGINEERING){ // us = LCLEMU_htons(d_Lcl_ENA_MODEID_IFE_ENGINEERING); // } // else if(uc == d_Lcl_ENA_MODE_IFE_TABLEREAD){ // us = LCLEMU_htons(d_Lcl_ENA_MODEID_IFE_TABLEREAD); // } // else if(uc == d_Lcl_ENA_MODE_NONPROCESS){ // us = LCLEMU_htons(d_Lcl_ENA_MODEID_NONPROCESS); // } // else if(uc == d_Lcl_ENA_MODE_IDLE){ // us = LCLEMU_htons(d_Lcl_ENA_MODEID_IDLE); // } // *(unsigned short *)Gui_ENA_AccumMat = us; //#else puc = (unsigned char *)Gui_ENA_AccumMat; switch (psp->uc_ProcessMode){ case d_Lcl_ENA_MODE_ACCUMMASS: *(unsigned short *)puc = LCLEMU_htons(d_Lcl_ENA_MODEID_ACCUMMASS); break; case d_Lcl_ENA_MODE_ACCUMCNT: *(unsigned short *)puc = LCLEMU_htons(d_Lcl_ENA_MODEID_ACCUMCNT); break; case d_Lcl_ENA_MODE_ACCUMTOF: *(unsigned short *)puc = LCLEMU_htons(d_Lcl_ENA_MODEID_ACCUMTOF); break; case d_Lcl_ENA_MODE_IFE_ENGINEERING: *(unsigned short *)puc = LCLEMU_htons(d_Lcl_ENA_MODEID_IFE_ENGINEERING); break; case d_Lcl_ENA_MODE_IFE_TABLEREAD: *(unsigned short *)puc = LCLEMU_htons(d_Lcl_ENA_MODEID_IFE_TABLEREAD); break; case d_Lcl_ENA_MODE_NONPROCESS: *(unsigned short *)puc = LCLEMU_htons(d_Lcl_ENA_MODEID_NONPROCESS); break; case d_Lcl_ENA_MODE_IDLE: *(unsigned short *)puc = LCLEMU_htons(d_Lcl_ENA_MODEID_IDLE); break; } //#endif puc += 2; puc += 2; // パケット先頭 3-4バイトめは空けること。TLM 出力時にサイズを入力するため。 //#ifndef d_ENA_ATTEMPT_TO_SMALLSIZE2 // 120416 // サイズ低減の効果はない // memcpy(puc, pucinbuf, 6); // puc += 6; //#else // 0x04 // TI0 (4byte) from sensor *puc++ = *pucinbuf; *puc++ = *(pucinbuf + 1); *puc++ = *(pucinbuf + 2); *puc++ = *(pucinbuf + 3); // 0x08 // TI1 (2byte) from sensor *puc++ = *(pucinbuf + 4); *puc++ = *(pucinbuf + 5); //#endif *puc++ = (0xf0 & (psp->uc_numE << 4)) | (0x0f & psp->uc_numC); *puc++ = psp->uc_numM; // 0x0c *puc++ = psp->uc_numP; *puc++ = psp->uc_numP0; *puc++ = psp->uc_startP; *puc++ = psp->uc_lenP; // 0x10 *(unsigned int *)(puc) = LCLEMU_htonl(psp->ui_CntOffset); // 4byte 境界に注意 puc += 4; // 0x14 *puc++ = (0xf0 & (psp->uc_SVRAMid << 4)) | (0x0f & psp->uc_CntDepth); *puc++ = (0xf0 & (psp->uc_num_add_interval_Spin_encoded << 4)) | (0x07 & psp->s_npm.uc_numProcessPckt_inSpin_encoded); *puc++ = psp->s_sHK.uc_autodiscri_hk; #ifdef d_ENA_AUTODISCRI_MDP // 120704 KA *puc++ = psp->s_adis_mdp.uc_autodiscri_hk; #endif // ヘッダサイズは d_Lcl_ENA_ACCUMTBL_HEADA_SIZE であることに注意すること。 // トリガ判定 if(psp->uc_trg_ena){ #ifdef d_ENA_LOCAL_EMU fprintf(stdout, "TRG2 %x %x %08x %08x %08x %08x\n", Gs_ENA_prm.uc_trg_curpos, Gs_ENA_prm.uc_trgset_flagset, Gs_ENA_prm.ui_trgset_ti, Gs_ENA_prm.ui_trgset_precnt, Gs_ENA_prm.ui_trgset_postcnt, Gs_ENA_prm.ui_trg_totalccnt0); #endif // トリガ判定データの保存 psp->ui_trg_totalccnt[psp->uc_trg_curpos] = psp->ui_trg_totalccnt0; psp->ui_trg_totalccnt[psp->uc_trg_curpos + d_Lcl_ENA_TRGDATA_NUM] = psp->ui_trg_totalccnt0; psp->ui_trg_totalccnt0 = 0; // トリガ前データ: uc_trg_prenum 個 // トリガ前データとトリガ後データの間にデータ 1個 (このデータの内容はチェックしない) // トリガ語データ: uc_trg_postnum 個 // このループでは時間的に後のデータからチェックしている。 ui = 0x0; ui2 = 0xffffffff; ui3 = 0xffffffff; ui4 = 0x0; for(i = 0; i < psp->uc_trg_prenum + psp->uc_trg_postnum + 1; i++){ j = psp->uc_trg_curpos + d_Lcl_ENA_TRGDATA_NUM - i; if(psp->ui_trg_totalccnt[j] >= d_Lcl_ENA_TRGDATA_INVALID){ break; } // 無効データ if(i < psp->uc_trg_postnum){ // トリガ後データチェック if(psp->ui_trg_totalccnt[j] < ui2){ ui2 = psp->ui_trg_totalccnt[j]; } if(psp->ui_trg_totalccnt[j] > ui4){ ui4 = psp->ui_trg_totalccnt[j]; } } if(i > psp->uc_trg_postnum){ // トリガ前データチェック if(psp->ui_trg_totalccnt[j] > ui ){ ui = psp->ui_trg_totalccnt[j]; } if(psp->ui_trg_totalccnt[j] < ui3){ ui3 = psp->ui_trg_totalccnt[j]; } } } uc_trgflg = FALSE; if(i == psp->uc_trg_prenum + psp->uc_trg_postnum + 1){ #ifdef d_ENA_LOCAL_EMU fprintf(stdout, "TRGa1 %x %x\n", ui, ui2); #endif if(psp->uc_trg_acqmode == d_Lcl_ENA_TRG_ABS){ // カウントの絶対値を基に判定 // psp->ui_trg_precnt <= psp->ui_trg_postcnt の場合はカウントが増加する場合を検出 // そうでない場合はカウントが減少する場合を検出 if(psp->ui_trg_precnt <= psp->ui_trg_postcnt){ if((ui <= psp->ui_trg_precnt) && (psp->ui_trg_postcnt <= ui2)){ uc_trgflg = TRUE; } } else { if((ui3 >= psp->ui_trg_precnt) && (psp->ui_trg_postcnt >= ui4)){ uc_trgflg = TRUE; } } } else { // カウント変化 (相対値) を基に判定 // psp->ui_trg_precnt <= psp->ui_trg_postcnt の場合: // psp->ui_trg_postcnt を増加閾値としてカウントが増加する場合を検出 // そうでない場合: // psp->ui_trg_precnt を減少閾値としてカウントが減少する場合を検出 if(psp->ui_trg_precnt <= psp->ui_trg_postcnt){ if((ui <= ui2) && (ui2 - ui >= psp->ui_trg_postcnt)){ uc_trgflg = TRUE; } } else { if((ui3 >= ui4) && (ui3 - ui4 >= psp->ui_trg_precnt)){ uc_trgflg = TRUE; } } } // トリガー時 TI に対応する Gc_TRG1_ENA (トリガフラグ変数) をサーチし、フラグをセット if(uc_trgflg == TRUE){ // トリガを現在時刻にあげる (2012.11.22 笠羽さん要請) // ここでは現在時刻ではなく処理を開始した観測データについている TI をトリガにセットする。 // 他タスクの負荷が重く、ENA データの処理が遅れた場合、現在時刻の TI をセットするのはよくない。 psp->ui_trgset_ti = (((unsigned int)pucinbuf[0]) << 24) + (((unsigned int)pucinbuf[1]) << 16) + (((unsigned int)pucinbuf[2]) << 8) + ( (unsigned int)pucinbuf[3]); psp->ui_trgset_ti += (((unsigned int)pucinbuf[4]) << 8) + ( (unsigned int)pucinbuf[5]); // if(psp->uc_trg_postnum == 0){ // psp->ui_trgset_ti = psp->ui_trg_ti[psp->uc_trg_curpos]; // } // else { // // postnum が 0 でない場合、postnum が始まった時のタイミングをトリガとする。 // psp->ui_trgset_ti = psp->ui_trg_ti[psp->uc_trg_curpos + d_Lcl_ENA_TRGDATA_NUM - psp->uc_trg_postnum + 1]; // } // psp->ui_trgset_ti = psp->ui_trg_ti[psp->uc_trg_curpos + d_Lcl_ENA_TRGDATA_NUM - psp->uc_trg_postnum]; if(psp->ui_trg_precnt <= psp->ui_trg_postcnt){ psp->ui_trgset_precnt = ui; psp->ui_trgset_postcnt = ui2; } else { psp->ui_trgset_precnt = ui3; psp->ui_trgset_postcnt = ui4; } i_trg_cnt = app_tiTrgSearch(psp->ui_trgset_ti, Gd_N_ENA); if(i_trg_cnt > 0){ Gc_TRG1_ENA[i_trg_cnt] = TRUE; psp->uc_trgset_flagset = TRUE; } else { psp->uc_trgset_flagset = FALSE; } #ifdef d_ENA_LOCAL_EMU fprintf(stdout, "TRG2a %x %x %08x %08x %08x %08x %08x\n", Gs_ENA_prm.uc_trg_curpos, Gs_ENA_prm.uc_trgset_flagset, Gs_ENA_prm.ui_trgset_ti, psp->ui_trg_ti[psp->uc_trg_curpos], Gs_ENA_prm.ui_trgset_precnt, Gs_ENA_prm.ui_trgset_postcnt, Gs_ENA_prm.ui_trg_totalccnt0); #endif // トリガが連続してかからないようにするため、トリガがかかったらトリガデータをクリアする。 // (1データ後でもトリガを立ててしまうなどがあり得るので。) for(i = 0; i < 2 * d_Lcl_ENA_TRGDATA_NUM; i++){ psp->ui_trg_ti[i] = 0; psp->ui_trg_totalccnt[i] = d_Lcl_ENA_TRGDATA_INVALID; } } } } #ifdef d_ENA_LOCAL_EMU fprintf(stdout, "TRG3 %x %x %08x %08x %08x %08x %08x\n", Gs_ENA_prm.uc_trg_curpos, Gs_ENA_prm.uc_trgset_flagset, Gs_ENA_prm.ui_trgset_ti, psp->ui_trg_ti[psp->uc_trg_curpos], Gs_ENA_prm.ui_trgset_precnt, Gs_ENA_prm.ui_trgset_postcnt, Gs_ENA_prm.ui_trg_totalccnt0); #endif // トリガ判定用ポインタ psp->uc_trg_curpos++; if(psp->uc_trg_curpos >= d_Lcl_ENA_TRGDATA_NUM){ psp->uc_trg_curpos = 0; } // トリガ判定用 TI psp->ui_trg_ti[psp->uc_trg_curpos] = (((unsigned int)pucinbuf[0]) << 24) + (((unsigned int)pucinbuf[1]) << 16) + (((unsigned int)pucinbuf[2]) << 8) + ( (unsigned int)pucinbuf[3]); psp->ui_trg_ti[psp->uc_trg_curpos] += (((unsigned int)pucinbuf[4]) << 8) + ( (unsigned int)pucinbuf[5]); psp->ui_trg_ti[psp->uc_trg_curpos + d_Lcl_ENA_TRGDATA_NUM] = psp->ui_trg_ti[psp->uc_trg_curpos]; } switch (psp->uc_ProcessMode){ case d_Lcl_ENA_MODE_ACCUMMASS: for(i = 0; i < islotnum; i++){ pucin = pucinbuf + i * d_Lcl_ENA_SIZE_SLOT; pspcpm->uc_packetID = *(pucin + 0x6); if(pspcpm->uc_packetID >= d_Lcl_ENA_SENSORMODE_NUM){ continue; } // packet ID から invalid data かどうかを判断する // TODO: coincidene mode でない場合の対応を加える if(pspcpm->uc_packetID != d_Lcl_ENA_SENSORMODE_COINCI){ continue; } pspcpm->uc_slotID = *(pucin + 0x7); // 4 * psp->uc_startP <= slotID < 4 * psp->uc_startP + 4 * psp->uc_lenP の範囲外の slotID の場合はスキップする if(pspcpm->uc_slotID < 4 * psp->uc_startP){ if(4 * (psp->uc_startP + psp->uc_lenP) <= pspcpm->uc_slotID + d_Lcl_ENA_SLOT_NUM){ continue; } } else { if(4 * (psp->uc_startP + psp->uc_lenP) <= pspcpm->uc_slotID){ continue; } } // トリガ判定データの保存 // total coincidence count psp->ui_trg_totalccnt0 += (unsigned int)(LCLEMU_ntohs( *(unsigned short *)(pucin + 0x8) )); pspcpm->uc_Estep = (pspcpm->uc_slotID & 0x07); // numP0 が 32 の場合、energy bin は最大 4 // この場合、energy step が 4毎の繰り返しになっているとして扱う (energy step0 = step4, step1 = step5, ... step3 = step7)。 // ---> SV RAM 選択に注意!! if(psp->uc_numP0 == 32){ pspcpm->uc_accumEid = ( (pspcpm->uc_Estep & 0x03) >> (psp->uc_shiftE - 1) ); } else { pspcpm->uc_accumEid = ( pspcpm->uc_Estep >> psp->uc_shiftE ); } pspcpm->uc_accumPid = ( (0x1f & ((pspcpm->uc_slotID + d_Lcl_ENA_SLOT_NUM) / 4 - psp->uc_startP)) >> psp->uc_shiftP ); #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "\nAM %x slotID %x Estep %x accumEid %x shiftE %x accumPid %x shiftP %x\n", i, pspcpm->uc_slotID, // pspcpm->uc_Estep, pspcpm->uc_accumEid, psp->uc_shiftE, pspcpm->uc_accumPid, psp->uc_shiftP); #endif // カウンタデータの加算 pui = Gui_ENA_AccumMat_mass_scale + (pspcpm->uc_accumPid * psp->uc_numE + pspcpm->uc_accumEid) * d_Lcl_ENA_COINCI_CNTNUM; pussrc = (unsigned short *)(pucin + 0x8); #ifdef d_ENA_LOCAL_EMU //fputs("AM2 count ", stdout); #endif for(j = 0; j < d_Lcl_ENA_COINCI_CNTNUM; j++){ // カウンタは 18個 #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "%04x ", *pussrc); #endif *pui++ += *pussrc++; } #ifdef d_ENA_LOCAL_EMU //fputs("\n", stdout); #endif // TOF event データのデコード・加算 // step 1 pspcpm->uc_Eindex = Guc_ENA_SVM[psp->uc_SVRAMid][pspcpm->uc_Estep]; // energy index #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "AM Step1 Eindex %x SVRAMid %x Estep %x\n", pspcpm->uc_Eindex, psp->uc_SVRAMid, pspcpm->uc_Estep); #endif // step 2 pspcpm->us_En = LCLEMU_ntohs(Gus_ENA_SVE[pspcpm->uc_Eindex]); // square root of energy #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "AM Step2 En %x Eindex %x\n", pspcpm->us_En, pspcpm->uc_Eindex); #endif pui = Gui_ENA_AccumMat_mass + pspcpm->uc_accumPid * psp->uc_numE * psp->uc_numC * psp->uc_numM + pspcpm->uc_accumEid * psp->uc_numC * psp->uc_numM; pui2 = Gui_ENA_AccumMat_mass + psp->uc_numP * psp->uc_numE * psp->uc_numC * psp->uc_numM + pspcpm->uc_accumPid * psp->uc_numE + pspcpm->uc_accumEid; #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "AM Step2_1 calc %x calc2 %x numP %x numE %x numC %x numM %x\n", // pspcpm->uc_accumPid * psp->uc_numE * psp->uc_numC * psp->uc_numM // + pspcpm->uc_accumEid * psp->uc_numC * psp->uc_numM, // psp->uc_numP * psp->uc_numE * psp->uc_numC * psp->uc_numM // + pspcpm->uc_accumPid * psp->uc_numE + pspcpm->uc_accumEid, // psp->uc_numP, psp->uc_numE, psp->uc_numC, psp->uc_numM); #endif puc = pucin + 0x8 + 2 * d_Lcl_ENA_COINCI_CNTNUM; for(j = 0; j < d_Lcl_ENA_EVTNUMMAX_COINCI; j++){ if(j & 0x1){ ui = ((*puc) & 0x0f) * 0x10000 + *(puc + 1) * 0x100 + *(puc + 2); // ui = ( ((*(unsigned int *)puc) >> 8) & 0xfffff); puc += 3; } else { ui = *puc * 0x1000 + *(puc + 1) * 0x10 + ((*(puc + 2)) >> 4); // ui = ( ((*(unsigned int *)puc) >> 12) & 0xfffff); puc += 2; } if(ui == 0){ break; } pspcpm->scdt.uc_startring = ( (ui >> 17) & 0x7); pspcpm->scdt.uc_startsect = ( (ui >> 14) & 0x7); pspcpm->scdt.uc_stopsectdiff = ( (ui >> 13) & 0x1); pspcpm->scdt.uc_stopsect = ( (ui >> 10) & 0x7); pspcpm->scdt.us_tof = ( ui & 0x3ff); #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "AM Step2_2 j %d ring %x strtsect %x stopdiff %x stopsect %x tof %03x\n", // j, pspcpm->scdt.uc_startring, pspcpm->scdt.uc_startsect, // pspcpm->scdt.uc_stopsectdiff, pspcpm->scdt.uc_stopsect, pspcpm->scdt.us_tof); #endif // 当該アノードで信号が検出されていない場合に ID をセット if(pspcpm->scdt.uc_startring >= d_Lcl_ENA_RINGNUM){ pspcpm->scdt.uc_startring = d_Lcl_ENA_RINGNUM; } if(pspcpm->scdt.uc_startsect >= d_Lcl_ENA_STARTSECTNUM){ // numC = 1 or 7 の場合は ch (START SECTOR) に無信号の TOF イベントは無視する。 if(psp->uc_numC == 1 || psp->uc_numC == 7){ continue; } pspcpm->scdt.uc_startsect = d_Lcl_ENA_STARTSECTNUM; } if(pspcpm->scdt.uc_stopsectdiff != 0){ pspcpm->scdt.uc_stopsect = d_Lcl_ENA_STOPSECTNUM; } #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "AM Step2_3 j %d ring %x strtsect %x stopdiff %x stopsect %x tof %03x\n", // j, pspcpm->scdt.uc_startring, pspcpm->scdt.uc_startsect, // pspcpm->scdt.uc_stopsectdiff, pspcpm->scdt.uc_stopsect, pspcpm->scdt.us_tof); #endif // inverse of flight path length pspcpm->us_Linv = LCLEMU_ntohs( Gus_ENA_LT[pspcpm->scdt.uc_startsect][pspcpm->scdt.uc_startring][pspcpm->scdt.uc_stopsect][pspcpm->uc_Eindex] ); // flight time pspcpm->us_T_1 = LCLEMU_ntohs( Gus_ENA_TT[pspcpm->scdt.us_tof] ); #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "AM Step2_4 Linv %x T_1 %x\n", pspcpm->us_Linv, pspcpm->us_T_1); #endif // step 3 // square root of mass pspcpm->ui_mass_0_5 = (((((unsigned int)pspcpm->us_En * pspcpm->us_T_1 * pspcpm->us_Linv) >> 16) * psp->us_MassFactor) >> 16); #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "AM Step3 mass_0_5 %x\n", pspcpm->ui_mass_0_5); #endif if(pspcpm->ui_mass_0_5 > 0xff){ pspcpm->ui_mass_0_5 = 0xff; } #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "AM Step3_2 mass_0_5 %x\n", pspcpm->ui_mass_0_5); #endif // step 4 pspcpm->uc_accumMid = ( (Guc_ENA_MT[pspcpm->ui_mass_0_5]) >> psp->uc_shiftM); #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "AM Step4 MT %x accumMid %x\n", Guc_ENA_MT[pspcpm->ui_mass_0_5], pspcpm->uc_accumMid); #endif // uc_numC = 2 のときは ch 無信号 TOF イベントを id=1 とする。信号が検出されているときは id=0 if(psp->uc_numC == 2){ if(pspcpm->scdt.uc_startsect >= d_Lcl_ENA_STARTSECTNUM){ pspcpm->uc_accumCid = 1; } else { pspcpm->uc_accumCid = 0; } } else { pspcpm->uc_accumCid = ( (pspcpm->scdt.uc_startsect) >> psp->uc_shiftC); } // step 5 if(0 == pspcpm->us_T_1 * pspcpm->us_Linv){ // invalid TOF event ( *pui2 )++; } else { // valid TOF event ( *(pui + pspcpm->uc_accumCid * psp->uc_numM + pspcpm->uc_accumMid) )++; // (*pui)++; } #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "AM Step5 calc %x accumCid %x\n", // pspcpm->uc_accumCid * psp->uc_numM + pspcpm->uc_accumMid, // pspcpm->uc_accumCid); #endif } // data を処理したら TRUE (処理データがない場合、FALSE で return する必要がある) uc_processflg = TRUE; } break; case d_Lcl_ENA_MODE_ACCUMCNT: for(i = 0; i < islotnum; i++){ pucin = pucinbuf + i * d_Lcl_ENA_SIZE_SLOT; pspcpm->uc_packetID = *(pucin + 0x6); if(pspcpm->uc_packetID >= d_Lcl_ENA_SENSORMODE_NUM){ continue; } // packet ID から invalid data かどうかを判断する // TODO: counter mode でない場合の対応を加える if(pspcpm->uc_packetID != d_Lcl_ENA_SENSORMODE_COUNT){ continue; } pspcpm->uc_slotID = *(pucin + 0x7); // 4 * psp->uc_startP <= slotID < 4 * psp->uc_startP + 4 * psp->uc_lenP の範囲外の slotID の場合はスキップする if(pspcpm->uc_slotID < 4 * psp->uc_startP){ if(4 * (psp->uc_startP + psp->uc_lenP) <= pspcpm->uc_slotID + d_Lcl_ENA_SLOT_NUM){ continue; } } else { if(4 * (psp->uc_startP + psp->uc_lenP) <= pspcpm->uc_slotID){ continue; } } // トリガ判定データの保存 // sum of coincidence start count for(j = 0; j < d_Lcl_ENA_STARTSECTNUM; j++){ psp->ui_trg_totalccnt0 += (unsigned int)(LCLEMU_ntohs( *(unsigned short *)(pucin + 0x66 + 2*j) )); } pspcpm->uc_Estep = (pspcpm->uc_slotID & 0x07); // numP0 が 32 の場合、energy bin は最大 4 // この場合、energy step が 4毎の繰り返しになっているとして扱う (energy step0 = step4, step1 = step5, ... step3 = step7)。 // ---> SV RAM 選択に注意!! if(psp->uc_numP0 == 32){ pspcpm->uc_accumEid = ( (pspcpm->uc_Estep & 0x03) >> (psp->uc_shiftE - 1) ); } else { pspcpm->uc_accumEid = ( pspcpm->uc_Estep >> psp->uc_shiftE ); } pspcpm->uc_accumPid = ( (0x1f & ((pspcpm->uc_slotID + d_Lcl_ENA_SLOT_NUM) / 4 - psp->uc_startP)) >> psp->uc_shiftP ); #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "AC1 PacketID %x slotID %x startP %x lenP %x Estep %x shiftE %x Eid %x numP0 %x shiftP %x Pid %x\n", // pspcpm->uc_packetID, pspcpm->uc_slotID, psp->uc_startP, psp->uc_lenP, pspcpm->uc_Estep, psp->uc_shiftE, // pspcpm->uc_accumEid, psp->uc_numP0, psp->uc_shiftP, pspcpm->uc_accumPid); #endif // カウンタデータの加算 pui = Gui_ENA_AccumMat_cnt_scale + (pspcpm->uc_accumPid * psp->uc_numE + pspcpm->uc_accumEid) * d_Lcl_ENA_COUNT_CNTNUM; #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "AC2 calc %x numP %x numE %x\n", // (pspcpm->uc_accumPid * psp->uc_numE + pspcpm->uc_accumEid) * d_Lcl_ENA_COUNT_CNTNUM, // psp->uc_numP, psp->uc_numE); #endif pussrc = (unsigned short *)(pucin + 0x8); #ifdef d_ENA_LOCAL_EMU //fputs("AC3 \n", stdout); #endif for(j = 0; j < d_Lcl_ENA_COUNT_CNTNUM; j++){ // カウンタは 62個 #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "%04x ", *pussrc); //if(j % 16 == 15){ fputs("\n ", stdout); } #endif *pui++ += *pussrc++; } #ifdef d_ENA_LOCAL_EMU //fputs("\n", stdout); #endif // data を処理したら TRUE (処理データがない場合、FALSE で return する必要がある) uc_processflg = TRUE; } break; case d_Lcl_ENA_MODE_ACCUMTOF: for(i = 0; i < islotnum; i++){ pucin = pucinbuf + i * d_Lcl_ENA_SIZE_SLOT; pspcpm->uc_packetID = *(pucin + 0x6); if(pspcpm->uc_packetID >= d_Lcl_ENA_SENSORMODE_NUM){ continue; } // packet ID から invalid data かどうかを判断する // TODO: coincidence mode でない場合の対応を加える if(pspcpm->uc_packetID != d_Lcl_ENA_SENSORMODE_COINCI){ continue; } pspcpm->uc_slotID = *(pucin + 0x7); // 4 * psp->uc_startP <= slotID < 4 * psp->uc_startP + 4 * psp->uc_lenP の範囲外の slotID の場合はスキップする if(pspcpm->uc_slotID < 4 * psp->uc_startP){ if(4 * (psp->uc_startP + psp->uc_lenP) <= pspcpm->uc_slotID + d_Lcl_ENA_SLOT_NUM){ continue; } } else { if(4 * (psp->uc_startP + psp->uc_lenP) <= pspcpm->uc_slotID){ continue; } } // トリガ判定データの保存 // total coincidence count psp->ui_trg_totalccnt0 += (unsigned int)(LCLEMU_ntohs( *(unsigned short *)(pucin + 0x8) )); pspcpm->uc_Estep = (pspcpm->uc_slotID & 0x07); // numP0 が 32 の場合、energy bin は最大 4 // この場合、energy step が 4毎の繰り返しになっているとして扱う (energy step0 = step4, step1 = step5, ... step3 = step7)。 // ---> SV RAM 選択に注意!! if(psp->uc_numP0 == 32){ pspcpm->uc_accumEid = ( (pspcpm->uc_Estep & 0x03) >> (psp->uc_shiftE - 1) ); } else { pspcpm->uc_accumEid = ( pspcpm->uc_Estep >> psp->uc_shiftE ); } #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "AT1 PacketID %x slotID %x startP %x lenP %x Estep %x shiftE %x Eid %x numP0 %x\n", // pspcpm->uc_packetID, pspcpm->uc_slotID, psp->uc_startP, psp->uc_lenP, pspcpm->uc_Estep, psp->uc_shiftE, // pspcpm->uc_accumEid, psp->uc_numP0); //fprintf(stdout, "AT2 calc %x\n", pspcpm->uc_accumEid * d_Lcl_ENA_COINCI_CNTNUM); #endif // カウンタデータの加算 #ifdef d_ENA_LOCAL_EMU //fputs("AT3 ", stdout); #endif pui = Gui_ENA_AccumMat_tof_scale + pspcpm->uc_accumEid * d_Lcl_ENA_COINCI_CNTNUM; pussrc = (unsigned short *)(pucin + 0x8); for(j = 0; j < d_Lcl_ENA_COINCI_CNTNUM; j++){ // カウンタは 18個 #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "%02x ", *pussrc); #endif *pui++ += *pussrc++; } #ifdef d_ENA_LOCAL_EMU //fputs("\n", stdout); #endif // TOF event データ #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "AT4 calc %x Eid %x TOF %x\n", pspcpm->uc_accumEid * psp->us_numTOF, pspcpm->uc_accumEid, psp->us_numTOF); #endif pui = Gui_ENA_AccumMat_tof + pspcpm->uc_accumEid * psp->us_numTOF; puc = pucin + 0x8 + 2 * d_Lcl_ENA_COINCI_CNTNUM; #ifdef d_ENA_LOCAL_EMU //fputs("AT5 ", stdout); #endif for(j = 0; j < d_Lcl_ENA_EVTNUMMAX_COINCI; j++){ if(j & 0x1){ ui = ((*puc) & 0x0f) * 0x10000 + *(puc + 1) * 0x100 + *(puc + 2); puc += 3; } else { ui = *puc * 0x1000 + *(puc + 1) * 0x10 + ((*(puc + 2)) >> 4); puc += 2; } if(ui == 0){ break; } // end marker pspcpm->scdt.us_tof = (0x3ff & ui); #ifdef d_ENA_LOCAL_EMU //fprintf(stdout, "us_tof %x ui %x ", pspcpm->scdt.us_tof, ui); #endif ( *(pui + pspcpm->scdt.us_tof) )++; } #ifdef d_ENA_LOCAL_EMU //fputs("\n", stdout); #endif // data を処理したら TRUE (処理データがない場合、FALSE で return する必要がある) uc_processflg = TRUE; } break; case d_Lcl_ENA_MODE_IFE_ENGINEERING: psp->s_npm.us_pcktsize = 0; for(i = 0; i < islotnum; i++){ if(psp->s_npm.us_numpckt_tgt != 0 && psp->s_npm.us_numpckt_sent >= psp->s_npm.us_numpckt_tgt){ continue; } pucin = pucinbuf + i * d_Lcl_ENA_SIZE_SLOT; pspcpm->uc_packetID = *(pucin + 0x6); if(pspcpm->uc_packetID >= d_Lcl_ENA_SENSORMODE_NUM){ continue; } // packet ID から invalid data かどうかを判断する // TODO: engineering mode でない場合の対応を加える if(pspcpm->uc_packetID != d_Lcl_ENA_SENSORMODE_ENG){ continue; } pspcpm->uc_slotID = *(pucin + 0x7); // 4 * psp->uc_startP <= slotID < 4 * psp->uc_startP + 4 * psp->uc_lenP の範囲外の slotID の場合はスキップする if(pspcpm->uc_slotID < 4 * psp->uc_startP){ if(4 * (psp->uc_startP + psp->uc_lenP) <= pspcpm->uc_slotID + d_Lcl_ENA_SLOT_NUM){ continue; } } else { if(4 * (psp->uc_startP + psp->uc_lenP) <= pspcpm->uc_slotID){ continue; } } // データ処理する slot を探す #ifdef d_ENA_ATTEMPT_TO_SMALLSIZE uc2 = psp->s_npm.uc_numProcessPckt_inSpin_encoded; if(uc2 == 4) { uc = 8; } else if(uc2 == 3) { uc = 16; } else if(uc2 == 2) { uc = 32; } else if(uc2 == 1) { uc = 64; } else { uc = 128; } #else switch(psp->s_npm.uc_numProcessPckt_inSpin_encoded){ case 4: uc = 8; break; case 3: uc = 16; break; case 2: uc = 32; break; case 1: uc = 64; break; case 0: default: uc = 128; break; } #endif #ifdef d_ENA_DEBUG_ENGMODE psp->ui_deng_ctr++; #endif // engineering mode (センサーモード) ではすべてのスロットに有効データが入るわけではない。 // 無効データ時にはスロット ID が 0 となる。スロットID のみで選別すると有効データを // 選択できない場合があるため、スロット ID にマスクをかけて用いる。 if(0 != ( (0x78 & (pspcpm->uc_slotID + d_Lcl_ENA_SLOT_NUM - 4 * Gs_ENA_prm.uc_startP) ) % uc)){ continue; } // if(0 != ( (pspcpm->uc_slotID + d_Lcl_ENA_SLOT_NUM - 4 * Gs_ENA_prm.uc_startP) % uc)){ continue; } puc = Guc_ENA_AccumMat_EngTblread + psp->s_npm.us_bufoffset + psp->s_npm.us_pcktsize; for(j = 0; j < d_Lcl_ENA_IFE_ENGINEERING_UNITDATASIZE; j++){ *puc++ = *pucin++; } psp->s_npm.us_pcktsize += d_Lcl_ENA_IFE_ENGINEERING_UNITDATASIZE; psp->s_npm.us_numpckt_sent++; // 処理パケット数のカウントアップ uc_processflg = TRUE; // data を処理したら TRUE (処理データがない場合、FALSE で return する必要がある) } break; case d_Lcl_ENA_MODE_IFE_TABLEREAD: case d_Lcl_ENA_MODE_NONPROCESS: psp->s_npm.us_pcktsize = 0; for(i = 0; i < islotnum; i++){ // psp->s_npm.us_numpckt_sent は 4エネルギーステップ分を処理するごとにインクリメント。 // 送信パケット数の単位は 8エネルギーステップなので、2倍異なる。 if(psp->s_npm.us_numpckt_tgt != 0 && psp->s_npm.us_numpckt_sent >= 2 * psp->s_npm.us_numpckt_tgt){ continue; } pucin = pucinbuf + i * d_Lcl_ENA_SIZE_SLOT; pspcpm->uc_packetID = *(pucin + 0x6); if(pspcpm->uc_packetID >= d_Lcl_ENA_SENSORMODE_NUM){ continue; } // packet ID から invalid data かどうかを判断する // TODO: table read mode でない場合の対応を加える if(psp->uc_ProcessMode == d_Lcl_ENA_MODE_IFE_TABLEREAD){ if(pspcpm->uc_packetID != d_Lcl_ENA_SENSORMODE_SVREAD){ continue; } } pspcpm->uc_slotID = *(pucin + 0x7); // slotID // 4 * psp->uc_startP <= slotID < 4 * psp->uc_startP + 4 * psp->uc_lenP の範囲外の slotID の場合はスキップする if(pspcpm->uc_slotID < 4 * psp->uc_startP){ if(4 * (psp->uc_startP + psp->uc_lenP) <= pspcpm->uc_slotID + d_Lcl_ENA_SLOT_NUM){ continue; } } else { if(4 * (psp->uc_startP + psp->uc_lenP) <= pspcpm->uc_slotID){ continue; } } // データ処理する slot を探す #ifdef d_ENA_ATTEMPT_TO_SMALLSIZE uc2 = psp->s_npm.uc_numProcessPckt_inSpin_encoded; if(uc2 == 4) { uc = 8; } else if(uc2 == 3) { uc = 16; } else if(uc2 == 2) { uc = 32; } else if(uc2 == 1) { uc = 64; } else { uc = 128; } #else switch(psp->s_npm.uc_numProcessPckt_inSpin_encoded){ case 4: uc = 8; break; case 3: uc = 16; break; case 2: uc = 32; break; case 1: uc = 64; break; case 0: default: uc = 128; break; } #endif // engineering mode (センサーモード) ではすべてのスロットに有効データが入るわけではない。 // 無効データ時にはスロット ID が 0 となる。 // non-process mode でセンサーモードが engineering mode の時には他モードと異なる動作となる。 // (uc が 8 でない場合、無効データスロットは除去すべきタイミングのものであっても選択されるなど) if(0 != ( (0x78 & pspcpm->uc_slotID) % uc) ){ continue; } puc = Guc_ENA_AccumMat_EngTblread + psp->s_npm.us_bufoffset + psp->s_npm.us_pcktsize; if(psp->uc_ProcessMode == d_Lcl_ENA_MODE_IFE_TABLEREAD){ if( (pspcpm->uc_slotID % 8) < 4){ i_len = d_Lcl_ENA_IFE_TABLEREAD_UNITDATASIZE_SV; // SV table の場合 } else { i_len = d_Lcl_ENA_IFE_TABLEREAD_UNITDATASIZE_ADIS; // auto discri table の場合 } } else { i_len = d_Lcl_ENA_SIZE_SLOT; } for(j = 0; j < i_len; j++){ *puc++ = *pucin++; } psp->s_npm.us_pcktsize += i_len; if(3 == (pspcpm->uc_slotID % 4)){ // slotID が 4n+3 だった時にカウントアップ psp->s_npm.us_numpckt_sent++; } uc_processflg = TRUE; // data を処理したら TRUE (処理データがない場合、FALSE で return する必要がある) } break; case d_Lcl_ENA_MODE_IDLE: break; } return uc_processflg; } char app04_ENA_Lin2Log(unsigned int *pinbuf, unsigned char *poutbuf, unsigned int len, unsigned char depth, unsigned int offset) { unsigned char uc; int i; unsigned int ui; if(depth == d_Lcl_ENA_CntDepth12){ for(i = 0; i < len/4; i++){ ui = *pinbuf++; if(ui < offset){ uc = 0; } else { ui -= offset; if ( !(ui & 0xffffffc0) ) { uc = (ui & 0x3f); } else if( !(ui & 0xffffff80) ) { uc = ( 0x40 + ((ui >> 1) & 0x1f) ); } else if( !(ui & 0xffffff00) ) { uc = ( 0x60 + ((ui >> 2) & 0x1f) ); } else if( !(ui & 0xfffffe00) ) { uc = ( 0x80 + ((ui >> 3) & 0x1f) ); } else if( !(ui & 0xfffffc00) ) { uc = ( 0xa0 + ((ui >> 4) & 0x1f) ); } else if( !(ui & 0xfffff800) ) { uc = ( 0xc0 + ((ui >> 5) & 0x1f) ); } else if( !(ui & 0xfffff000) ) { uc = ( 0xe0 + ((ui >> 6) & 0x1f) ); } else { uc = 0xff; } } *poutbuf++ = uc; } } else if(depth == d_Lcl_ENA_CntDepth16){ for(i = 0; i < len/4; i++){ ui = *pinbuf++; if(ui < offset){ uc = 0; } else { ui -= offset; if ( !(ui & 0xffffffc0) ) { uc = (ui & 0x3f); } else if( !(ui & 0xffffff80) ) { uc = ( 0x40 + ((ui >> 1) & 0x1f) ); } else if( !(ui & 0xffffff00) ) { uc = ( 0x60 + ((ui >> 2) & 0x1f) ); } else if( !(ui & 0xfffffe00) ) { uc = ( 0x80 + ((ui >> 4) & 0x0f) ); } else if( !(ui & 0xfffffc00) ) { uc = ( 0x90 + ((ui >> 5) & 0x0f) ); } else if( !(ui & 0xfffff800) ) { uc = ( 0xa0 + ((ui >> 6) & 0x0f) ); } else if( !(ui & 0xfffff000) ) { uc = ( 0xb0 + ((ui >> 7) & 0x0f) ); } else if( !(ui & 0xffffe000) ) { uc = ( 0xc0 + ((ui >> 8) & 0x0f) ); } else if( !(ui & 0xffffc000) ) { uc = ( 0xd0 + ((ui >> 9) & 0x0f) ); } else if( !(ui & 0xffff8000) ) { uc = ( 0xe0 + ((ui >> 10) & 0x0f) ); } else if( !(ui & 0xffff0000) ) { uc = ( 0xf0 + ((ui >> 11) & 0x0f) ); } else { uc = 0xff; } } *poutbuf++ = uc; } } else { for(i = 0; i < len/4; i++){ ui = *pinbuf++; if(ui < offset){ uc = 0; } else { ui -= offset; if ( !(ui & 0xffffffe0) ) { uc = (ui & 0x1f); } else if( !(ui & 0xffffffc0) ) { uc = ( 0x20 + ((ui >> 1) & 0x0f) ); } else if( !(ui & 0xffffff80) ) { uc = ( 0x30 + ((ui >> 3) & 0x07) ); } else if( !(ui & 0xffffff00) ) { uc = ( 0x38 + ((ui >> 4) & 0x07) ); } else if( !(ui & 0xfffffe00) ) { uc = ( 0x40 + ((ui >> 5) & 0x07) ); } else if( !(ui & 0xfffffc00) ) { uc = ( 0x48 + ((ui >> 6) & 0x07) ); } else if( !(ui & 0xfffff800) ) { uc = ( 0x50 + ((ui >> 7) & 0x07) ); } else if( !(ui & 0xfffff000) ) { uc = ( 0x58 + ((ui >> 8) & 0x07) ); } else if( !(ui & 0xffffe000) ) { uc = ( 0x60 + ((ui >> 9) & 0x07) ); } else if( !(ui & 0xffffc000) ) { uc = ( 0x68 + ((ui >> 10) & 0x07) ); } else if( !(ui & 0xffff8000) ) { uc = ( 0x70 + ((ui >> 11) & 0x07) ); } else if( !(ui & 0xffff0000) ) { uc = ( 0x78 + ((ui >> 12) & 0x07) ); } else if( !(ui & 0xfffe0000) ) { uc = ( 0x80 + ((ui >> 13) & 0x07) ); } else if( !(ui & 0xfffc0000) ) { uc = ( 0x88 + ((ui >> 14) & 0x07) ); } else if( !(ui & 0xfff80000) ) { uc = ( 0x90 + ((ui >> 15) & 0x07) ); } else if( !(ui & 0xfff00000) ) { uc = ( 0x98 + ((ui >> 16) & 0x07) ); } else if( !(ui & 0xffe00000) ) { uc = ( 0xa0 + ((ui >> 17) & 0x07) ); } else if( !(ui & 0xffc00000) ) { uc = ( 0xa8 + ((ui >> 18) & 0x07) ); } else if( !(ui & 0xff800000) ) { uc = ( 0xb0 + ((ui >> 19) & 0x07) ); } else if( !(ui & 0xff000000) ) { uc = ( 0xb8 + ((ui >> 20) & 0x07) ); } else if( !(ui & 0xfe000000) ) { uc = ( 0xc0 + ((ui >> 21) & 0x07) ); } else if( !(ui & 0xfc000000) ) { uc = ( 0xc8 + ((ui >> 22) & 0x07) ); } else if( !(ui & 0xf8000000) ) { uc = ( 0xd0 + ((ui >> 23) & 0x07) ); } else if( !(ui & 0xf0000000) ) { uc = ( 0xd8 + ((ui >> 24) & 0x07) ); } else if( !(ui & 0xe0000000) ) { uc = ( 0xe0 + ((ui >> 25) & 0x07) ); } else if( !(ui & 0xc0000000) ) { uc = ( 0xe8 + ((ui >> 26) & 0x07) ); } else if( !(ui & 0x80000000) ) { uc = ( 0xf0 + ((ui >> 27) & 0x07) ); } else { uc = ( 0xf8 + ((ui >> 28) & 0x07) ); } } *poutbuf++ = uc; } } return TRUE; } char app04_ENA_DumpTbl(M_T_TIME_INFO *pt_timeInfo) // // テーブルデータ (EEPROM and/or MDP RAM) をダンプする。 { unsigned char *puc, *puc_src; unsigned short us_flg = 0, us_size = 0, us_size_1pckt = 0; #ifndef d_ENA_ATTEMPT_TO_SMALLSIZE2 // 120416 int i; #endif if(0x0000 == (d_Lcl_ENA_DUMP_TGTIDMASK & Gs_ENA_prm.s_dmp.us_dump_target)){ return FALSE; } puc_src = &Guc_ENA_SVM[0][0]; // 初期化 (コンパイル時の uninitialized warning 対策) if(d_Lcl_ENA_DUMP_TGTID_SVM_RAM & Gs_ENA_prm.s_dmp.us_dump_target){ // SVM puc_src = &Guc_ENA_SVM[0][0]; us_flg = d_Lcl_ENA_DUMP_TGTID_SVM_RAM; us_size = d_Lcl_ENA_SVTBLNUM * d_Lcl_ENA_ESTEPNUM; } else if(d_Lcl_ENA_DUMP_TGTID_SVE_RAM & Gs_ENA_prm.s_dmp.us_dump_target){ // SVE puc_src = (unsigned char *)&Gus_ENA_SVE[0]; us_flg = d_Lcl_ENA_DUMP_TGTID_SVE_RAM; us_size = 2 * d_Lcl_ENA_EINDEX_NUM; } else if(d_Lcl_ENA_DUMP_TGTID_MT_RAM & Gs_ENA_prm.s_dmp.us_dump_target){ // MT puc_src = &Guc_ENA_MT[0]; us_flg = d_Lcl_ENA_DUMP_TGTID_MT_RAM; us_size = d_Lcl_ENA_M_0_5_MAX; } else if(d_Lcl_ENA_DUMP_TGTID_Discri_RAM & Gs_ENA_prm.s_dmp.us_dump_target){ // Discri puc_src = &Guc_ENA_DiscriTbl_RAM[0][0]; us_flg = d_Lcl_ENA_DUMP_TGTID_Discri_RAM; us_size = d_Lcl_ENA_DISCRITBLNUM_RAM * d_Lcl_ENA_DISCRITBL_DATANUM_STORE; } else if(d_Lcl_ENA_DUMP_TGTID_AutoDiscri_RAM & Gs_ENA_prm.s_dmp.us_dump_target){ // AutoDiscri puc_src = &Guc_ENA_AutoDiscriTbl_RAM[0][0][0]; us_flg = d_Lcl_ENA_DUMP_TGTID_AutoDiscri_RAM; us_size = d_Lcl_ENA_AUTODISCRITBLNUM_RAM * d_Lcl_ENA_AUTODISCRITBL_TNUM * d_Lcl_ENA_AUTODISCRITBL_DATANUM_STORE; } else if(d_Lcl_ENA_DUMP_TGTID_TT_RAM & Gs_ENA_prm.s_dmp.us_dump_target){ // TT puc_src = (unsigned char *)&Gus_ENA_TT[0]; us_flg = d_Lcl_ENA_DUMP_TGTID_TT_RAM; us_size = 2 * d_Lcl_ENA_TOFNUM; } else if(d_Lcl_ENA_DUMP_TGTID_LT_RAM & Gs_ENA_prm.s_dmp.us_dump_target){ // LT puc_src = (unsigned char *)&Gus_ENA_LT[0][0][0][0]; us_flg = d_Lcl_ENA_DUMP_TGTID_LT_RAM; us_size = 2 * (d_Lcl_ENA_STARTSECTNUM + 1) * (d_Lcl_ENA_RINGNUM + 1) * (d_Lcl_ENA_STOPSECTNUM + 1) * d_Lcl_ENA_EINDEX_NUM; } else if(d_Lcl_ENA_DUMP_TGTID_MacroCmd_RAM & Gs_ENA_prm.s_dmp.us_dump_target){ // マクロコマンド puc_src = &Guc_ENA_MacroCmdTbl_RAM[0][0]; us_flg = d_Lcl_ENA_DUMP_TGTID_MacroCmd_RAM; us_size = d_Lcl_ENA_MACROCMDTblNUM_RAM * d_Lcl_ENA_MACROCMDTbl_size; } #ifdef d_ENA_AUTODISCRI_MDP // 120704 KA else if(d_Lcl_ENA_DUMP_TGTID_AutoDiscri_MDP & Gs_ENA_prm.s_dmp.us_dump_target){ // マクロコマンド puc_src = &Gs_ENA_prm.s_adis_mdp.uc_tbl_adiscri[0][0][0]; us_flg = d_Lcl_ENA_DUMP_TGTID_AutoDiscri_MDP; us_size = 2 * d_Lcl_ENA_AUTODISCRITBL_TNUM * d_Lcl_ENA_AUTODISCRITBL_DATANUM_STORE; } #endif else if(d_Lcl_ENA_DUMP_TGTID_EEPROM & Gs_ENA_prm.s_dmp.us_dump_target){ // EEPROM us_flg = d_Lcl_ENA_DUMP_TGTID_EEPROM; us_size = Gs_ENA_prm.s_dmp.us_size; // EEPROM テーブルサイズ (for ENA) を超えないようにする。 if(d_Lcl_ENA_EEPROM_TBL_SIZE <= Gs_ENA_prm.s_dmp.ui_address){ us_size = 0; } else if(d_Lcl_ENA_EEPROM_TBL_SIZE < Gs_ENA_prm.s_dmp.ui_address + us_size){ us_size = d_Lcl_ENA_EEPROM_TBL_SIZE - Gs_ENA_prm.s_dmp.ui_address; } } if(us_size > Gs_ENA_prm.s_dmp.us_size){ us_size = Gs_ENA_prm.s_dmp.us_size; } us_size_1pckt = 0; if(us_size > Gs_ENA_prm.s_dmp.us_outsize_eachtarget){ us_size_1pckt = us_size - Gs_ENA_prm.s_dmp.us_outsize_eachtarget; } if(us_size_1pckt > d_Lcl_ENA_MISSION_DUMPPCKT_SIZE_MAX - d_Lcl_ENA_DUMP_PCKT_HEADA_SIZE){ us_size_1pckt = d_Lcl_ENA_MISSION_DUMPPCKT_SIZE_MAX - d_Lcl_ENA_DUMP_PCKT_HEADA_SIZE; } puc = (unsigned char *)Gui_ENA_Dumpbuf; *(unsigned short *)puc = LCLEMU_htons(d_Lcl_ENA_MODEID_DUMP); // 2 byte 境界に置くこと puc += 2; puc += 2; // サイズ入力用に空ける。 *(unsigned int *)puc = LCLEMU_htonl(pt_timeInfo->ui_sunpulseTime); // 衛星時刻 サンパルス受信時刻 puc += 4; *(unsigned short *)puc = LCLEMU_htons(pt_timeInfo->ui_currentTime - pt_timeInfo->ui_sunpulseTime); // サンパルス受信時刻からの経過時間 puc += 2; *(unsigned short *)puc = LCLEMU_htons(us_flg); // 2 byte 境界に置くこと puc += 2; *(unsigned int *)puc = LCLEMU_htonl(Gs_ENA_prm.s_dmp.ui_address); // 4 byte 境界に置くこと puc += 4; *(unsigned short *)puc = LCLEMU_htons(Gs_ENA_prm.s_dmp.us_outsize_eachtarget); // 2 byte 境界に置くこと puc += 2; *(unsigned short *)puc = LCLEMU_htons(us_size_1pckt); // 2 byte 境界に置くこと puc += 2; *(unsigned short *)puc = LCLEMU_htons(us_size); // 2 byte 境界に置くこと puc += 2; puc = ((unsigned char *)Gui_ENA_Dumpbuf) + d_Lcl_ENA_DUMP_PCKT_HEADA_SIZE; if(us_flg == d_Lcl_ENA_DUMP_TGTID_EEPROM){ // EEPROM の read app_readROM(Gd_ENA_RomAdr + Gs_ENA_prm.s_dmp.ui_address + Gs_ENA_prm.s_dmp.us_outsize_eachtarget, us_size_1pckt, puc); } else { puc_src += Gs_ENA_prm.s_dmp.us_outsize_eachtarget; #ifdef d_ENA_ATTEMPT_TO_SMALLSIZE2 // 120416 memcpy(puc, puc_src, us_size_1pckt); #else for(i = 0; i < us_size_1pckt; i++){ *puc++ = *puc_src++; } #endif } if(us_size_1pckt > 0){ app04_ENA_tlmout((unsigned char *)&Gui_ENA_Dumpbuf[0], us_size_1pckt + d_Lcl_ENA_DUMP_PCKT_HEADA_SIZE, TRUE, TRUE); } Gs_ENA_prm.s_dmp.us_outsize_eachtarget += us_size_1pckt; if(us_size <= Gs_ENA_prm.s_dmp.us_outsize_eachtarget){ Gs_ENA_prm.s_dmp.us_outsize_eachtarget = 0; Gs_ENA_prm.s_dmp.us_dump_target &= (~us_flg); // dump が終わったので該当ターゲットのフラグを降ろす。 } return TRUE; }