//2014.01.16
/*******************************************************************************
* 繝｢繧ｸ繝･繝ｼ繝ｫ蜷咲ｧｰ ｼ哂PP03 Mission TLM (L&M) PI tasks *
* 繝｢繧ｸ繝･繝ｼ繝ｫ繝ｩ繝吶Ν ｼ啾pp03_PIs *
* 繧ｿ繧ｹ繧ｯ蛹ｺ蛻 ｼ哂pplication-03 MIA task for Mission TLM (L&M) *
* 讖溯 ｼ *
* 繧ｳ繝ｼ繝ｪ繝ｳ繧ｰ繧ｷ繝ｼ繧ｱ繝ｳ繧ｹｼ嘛oid app03_(PI) *
* 蠑墓焚 ｼ壹↑縺 *
* 謌ｻ繧雁､ ｼ壹↑縺 *
* 菴ｿ逕ｨ荳翫豕ｨ諢 ｼ壹げ繝ｭ繝ｼ繝舌Ν螟画焚縺ｯ繧｢繝励Μ繧ｱ繝ｼ繧ｷ繝ｧ繝ｳｼ撰ｼ代〒縺ｾ縺ｨ繧√※蛻晄悄蛹 *
* 繧ｨ繝ｩ繝ｼ蜃ｦ逅 ｼ壹↑縺 *
* 豕ｨ諢 ｼ EDIT讓ｩ髯舌縲｀PPE/MIA邨 *
* 菴懈譌･繝ｻ菴懈閠 ｼ2012/11/25 Y.K. *
*******************************************************************************/
//#include "dpu_api.h"
//#include "dpu_api_proto.h"
#include "app_common.h"
#include "app_MPPE-MIA.h"
#include "app_comp_rice.h"
//########## 繝ヰ繝げ逕ｨ ##########
#ifdef _RUN_ON_WINDOWS_
#include "mylib.h"
#endif
int app03_MIA_GetVelcity(int, int);
char app03_MIA_CalcVM(int, int, int, int, int*, int, int, unsigned short*, double*);
void app03_MIA( unsigned int ui_sunpulseCnt )
{
int i, j;
int i_flag;
//
// === BLOCK read ===
int i_bufId, i_bufId2; // Buffer ID ***
int i_numNewBlock, i_numNewBlock2; // Num of blocks with new data ***
unsigned int ui_timeData; // Processing data TI ***
M_T_BLOCK_INFO t_blockInfo; // unsigned int ui_createTime Block 逕滓髢句ｧ区凾陦帶弌譎ょ綾(1LSB=1,953ms)
unsigned char uc_modeNo, uc_segNo, uc_segNoEnd;
unsigned char uc_find_pac0;
unsigned char *puc_dat;
unsigned short *pus_dat;
//DEBUG
#ifdef _GET_WORKING_TIME_MIA__03
M_T_TIME_INFO t_timeInfo;
unsigned int ui_tmp1, ui_tmp2, ui_tmp3;
i_flag = dpu_getTime( &t_timeInfo);
ui_tmp1 = t_timeInfo.ui_currentTime2;
#endif
struct _s_MIA_CtrlParam *pCtrl; //蛻ｶ蠕｡逕ｨ縺ｮ繝輔Λ繧ｰ蜿翫繝代Λ繝｡繝ｼ繧ｿ
pCtrl = &Gst_MIA_ctrl;
uc_find_pac0 = FALSE; //蜈磯ｭ讀懷繝輔Λ繧ｰ縺ｮ蛻晄悄蛹
uc_modeNo=0; uc_segNo =0; uc_segNoEnd =0;
puc_dat = G03uc_data + 4;
pus_dat = (unsigned short*)puc_dat; // 縺薙縺ｾ縺ｾ3D-LL縺ｫ菴ｿ縺◆繧ゝI繧堤ｩｺ縺代ｋ
// -----------------------------------------------------------
// -- Set at the buffer with the oldest non-processed block --
// -----------------------------------------------------------
i_bufId = app_CheckNonProcBlock ( Gd_N_MIA, 0, // [INPUT] Node/Data ID
Gui_TLMm_blockTime[Gd_N_MIA], // [INPUT] TI of Processed Block
& ui_timeData); // [OUTPUT] TI of Newest Block in the selected buffer ***
// (return) Buffer-ID (0:L, 1:S, -1:no data) ***
if ( i_bufId < 0 ) return; // === No data ===
// -------------------------------------------
// -- Set at the oldest non-processed block --
// -------------------------------------------
// Newest Block
i_numNewBlock = app_SetNonProcBlock(Gd_N_MIA, 0, // [INPUT] Node/Data ID
i_bufId, // [INPUT] Buffer ID
Gui_TLMm_blockTime[Gd_N_MIA], // [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_MIA] = ui_timeData; // === shift to newest data for SKIP ===
return;
}
if ( i_numNewBlock > 3) i_numNewBlock = 3;
//1繝代こ繝ヨ(12+5260+1+7 = 5280B)
//1繝悶Ο繝け(5280 x 25 = 132000B)
// ---------------------
// -- Read Block data --
// ---------------------
for (i=0; i<i_numNewBlock; i++) {
if ( t_blockInfo.ui_createTime > Gui_TLMm_blockTime[Gd_N_MIA] && // NEW data
t_blockInfo.i_replyNum > 0 && // Data available
t_blockInfo.c_invalidFlg == 0 ) { // Data correct
//1BLOCK荳ｭ縺ｫ蜈磯ｭ繝代こ繝ヨ縺ｮ菴咲ｽｮ縺ｯ荳榊ｮ
//1SPIN蛻繝繧ｿ縺2BLOCK縺ｫ霍ｨ繧句ｴ蜷医′縺ゅｋ
//
for (j = 0; j < 25; ++j) {
//蜈医↓MISSION繝倥ャ繝縺ｮ縺ｿ隱ｭ縺ｿ霎ｼ縺ｿ縲√ム繝溘繝代こ繝ヨ縺ｮ蝣ｴ蜷医繧ｹ繧ｭ繝
i_flag = app_GetPacket( 3, // [INPUT] App-No:3
Gd_N_MIA, 0, // [INPUT] NodeID = Gd_N_MIA, Data ID = 0
i_bufId, // [INPUT] Buffer ID
&t_blockInfo, // [INPUT] Block Info
j, // [INPUT] Packet No (蜈磯ｭ:0)
0, // [INPUT] OFFSET隱ｭ蜃ｺ髢句ｧ狗分蝨ｰ(8縺ｮ蛟肴焚ｼ
32, // [INPUT] 隱ｭ蜃ｺ繝繧ｿ謨ｰ:
G03uc_packet); // [OUTPUT] 1 Block Data - copied
if ( i_flag ) continue;
uc_segNo = G03uc_packet[d_Lcl_MIA_SGN_ADRR];//繧ｻ繧ｰ繝｡繝ｳ繝育分蜿ｷ縺後ム繝溘繧堤､ｺ縺励◆蝣ｴ蜷医繧ｹ繧ｭ繝
if (uc_segNo == 0xff || uc_segNo > 0x0f) continue;
//繝代こ繝ヨ蜈ｨ縺ｦ繧定ｪｭ縺ｿ霎ｼ縺ｿ
i_flag = app_GetPacket( 3, // [INPUT] App-No:3
Gd_N_MIA, 0, // [INPUT] NodeID = Gd_N_MIA, Data ID = 0
i_bufId, // [INPUT] Buffer ID
&t_blockInfo, // [INPUT] Block Info
j, // [INPUT] Packet No (蜈磯ｭ:0)
0, // [INPUT] OFFSET隱ｭ蜃ｺ髢句ｧ狗分蝨ｰ(8縺ｮ蛟肴焚ｼ
d_Lcl_MIA_PAC_SIZE, // [INPUT] 隱ｭ蜃ｺ繝繧ｿ謨ｰ:
G03uc_packet); // [OUTPUT] 1 Packet Data - copied
if ( i_flag ) continue;
//鬆ｭ蜃ｺ縺
if (uc_segNo == 0) {
uc_find_pac0 = TRUE;
//隕ｳ貂ｬ繝｢繝ｼ繝峨↓蠢懊§縺ｦ繧ｻ繧ｰ繝｡繝ｳ繝育分蜿ｷ縺ｮ譛ｫ蟆ｾ繧貞ｮ夂ｾｩ
uc_modeNo = (G03uc_packet[d_Lcl_MIA_MOD_ADRR] >> 4) & 0x0f;
if (uc_modeNo == 0) uc_segNoEnd = 0x0b;
else if (uc_modeNo == 1) uc_segNoEnd = 0x0f;
else if (uc_modeNo == 2) uc_segNoEnd = 0x0f;
else uc_segNoEnd = 0;
//FOR DEBUG
//辟｡逅ｄ繧翫Δ繝ｼ繝臥分蜿ｷ繧貞ｮ夂ｾｩ, SWcal縺ｨ菴ｵ逕ｨ
//uc_modeNo = 2;
//G03uc_packet[d_Lcl_MIA_MOD_ADRR] |= (uc_modeNo << 4) & 0xf0;
//SIC繝倥ャ繝縺ｮ隱ｭ縺ｿ霎ｼ縺ｿ
app03_MIA_readHDRPacket(G03uc_packet, //[INPUT] Raw Packet data
FALSE); //[INPUT] H mode FLAG
}
//鬆ｭ蜃ｺ縺嶺ｻ･蠕
//ScienceData繧置c_data縺ｫ蜀埼鄂ｮ縺吶ｋ
if (uc_find_pac0 && uc_segNo <= uc_segNoEnd) {
//繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮ隱ｭ縺ｿ霎ｼ縺ｿ
app03_MIA_readSCIPacket(G03uc_packet, //[INPUT] Raw Packet data
puc_dat ); //[OUTPUT]Count data 1繧ｹ繝斐Φ蛻叙蠕怜ｾ後Ν繝ｼ繝励ｒ謚懊¢繧
//
// Debug逕ｨ縲∝推繝代こ繝ヨ縺ｮ蜈磯ｭ32B縺縺第栢邊
//
//memcpy(G03uc_data + 32*uc_segNo, G03uc_packet + 12, 32);
//memcpy(G03uc_data + 32*j, G03uc_packet + 12, 32);
}
//縺雁ｰｻ蜃ｺ縺
if (uc_find_pac0 && uc_segNo == uc_segNoEnd) {
uc_find_pac0 = FALSE;
if (pCtrl->uc_swcal_prm[0]) {
//SW cal ON譎: 繝せ繝育畑繝代Ν繧ｹ縺ｧ繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ繧剃ｸ頑嶌縺阪☆繧
app03_MIA_makeSWcal(pus_dat, //[OUTPUT] Buffer for Count data
uc_modeNo); //[INPUT] 繝｢繝ｼ繝臥分蜿ｷ
}
//EMU縺ｮTI繧剃ｸ頑嶌縺
#ifdef _RUN_WITH_EMU_MIA__
Gst_MIA_dat.ui_TIL = t_blockInfo.ui_createTime;
#endif
//繝励Ο繝繧ｯ繝医菴懈
//L繝励Ο繝繧ｯ繝
app03_MIA_makeL( ui_sunpulseCnt, // [INPUT] 繧ｵ繝ｳ繝代Ν繧ｹ
pus_dat, // [INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ
Gst_MIA_dat.us_Ldata, // [OUTPUT] 繝励Ο繝繧ｯ繝育畑繝舌ャ繝輔ぃ
(unsigned short*)G03uc_packet); // [MID] 蝨ｧ邵ｮ蠕後繝舌ャ繝輔ぃ
// app03_MIA_tlmout( Gus_MPPE_Ldata, // [INPUT]繝励Ο繝繧ｯ繝
// (unsigned short*)G03uc_packet, // [MID] 蝨ｧ邵ｮ蠕後繝舌ャ繝輔ぃ
// 0); //[INPUT]L-mode data flag
//M繝励Ο繝繧ｯ繝
app03_MIA_makeM( ui_sunpulseCnt, // [INPUT] 繧ｵ繝ｳ繝代Ν繧ｹ
pus_dat, // [INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ
Gst_MIA_dat.us_3DL2, // [OUTPUT] 繝励Ο繝繧ｯ繝井ｸ蠑
pus_dat); // [MID] 蝨ｧ邵ｮ蠕後繝舌ャ繝輔ぃ
// app03_MIA_tlmout2((unsigned short*)G03uc_data, // [INPUT]繝励Ο繝繧ｯ繝
// (unsigned short*)G03uc_packet, // [MID] 蝨ｧ邵ｮ蠕後繝舌ャ繝輔ぃ
// 0);
}
}
//繝悶Ο繝けTI繧呈峩譁ｰ縺吶ｋ
if (uc_find_pac0 && i_numNewBlock - i > 1) //1spin蛻ョ繝ｼ繧ｿ縺梧純繧上↑縺′Block縺梧ｮ九▲縺ｦ縺ｋ蝣ｴ蜷
Gui_TLMm_blockTime[Gd_N_MIA] = t_blockInfo.ui_createTime;//谺｡繧ｹ繝斐Φ譎ゅ縺薙TI逶ｴ蠕後繝悶Ο繝け縺九ｉ
else if (!uc_find_pac0) //1spin蛻ョ繝ｼ繧ｿ縺梧純縺｣縺溽憾諷九〒Block邨ゆｺ
Gui_TLMm_blockTime[Gd_N_MIA] = t_blockInfo.ui_createTime;//谺｡繧ｹ繝斐Φ譎ゅ縺薙TI逶ｴ蠕後繝悶Ο繝け縺九ｉ
else if (uc_segNo == 0xff) //譛蠕後繝代こ繝ヨ縺後ム繝溘繝代こ繝ヨ
Gui_TLMm_blockTime[Gd_N_MIA] = t_blockInfo.ui_createTime;//谺｡繧ｹ繝斐Φ譎ゅ縺薙TI逶ｴ蠕後繝悶Ο繝け縺九ｉ
}
//繝悶Ο繝け謨ｰ縺1縺ｧ鬆ｭ譛峨√♀蟆ｻ辟｡縺 --> !!!繝舌ャ繝輔ぃ蛻ｊ譖ｿ縺医蜿ｯ閭ｽ諤ｧ!!!
if (uc_find_pac0 && i_numNewBlock == 1) {
i_bufId2 = app_CheckNonProcBlock ( Gd_N_MIA, 0, // [INPUT] Node/Data ID
t_blockInfo.ui_createTime, // [INPUT] TI of Processed Block
& ui_timeData); // [OUTPUT] TI of Newest Block in the selected buffer ***
// (return) Buffer-ID (0:L, 1:S, -1:no data) ***
if ( i_bufId2 >= 0 && i_bufId != i_bufId2) { //繝舌ャ繝輔ぃ蛻ｊ譖ｿ縺医′1繧ｹ繝斐Φ繝繧ｿ縺ｮ蛻ｌ逶ｮ縺ｫ譛峨ｊ
Gui_TLMm_blockTime[Gd_N_MIA] = t_blockInfo.ui_createTime;//谺｡繧ｹ繝斐Φ譎ゅ縺薙TI逶ｴ蠕後繝悶Ο繝け縺九ｉ
// Newest Block-- Set at the oldest non-processed block --
i_numNewBlock2 = app_SetNonProcBlock(Gd_N_MIA, 0, // [INPUT] Node/Data ID
i_bufId2, // [INPUT] Buffer ID
Gui_TLMm_blockTime[Gd_N_MIA], // [INPUT] TI of Processed Block
&t_blockInfo); // [OUTPUT] Block Info ***
// (return) >0:Num of blocks, <=0:No data (error) ***
if ( i_numNewBlock2 > 3) i_numNewBlock2 = 3;
if ( i_numNewBlock2 >= 1 ) {
i_numNewBlock += i_numNewBlock2;
i_bufId = i_bufId2;
continue;
}
}
}
// To next block
i_flag = app_NextBlock( Gd_N_MIA, 0, // [INPUT] Node/Data ID
i_bufId, // [INPUT] Buffer ID
&t_blockInfo); // [OUTPUT] Block Info
if ( i_flag ) break; // no data
}
//DEBUG
#ifdef _GET_WORKING_TIME_MIA__03
dpu_getTime( &t_timeInfo);
ui_tmp2 = t_timeInfo.ui_currentTime2;
ui_tmp3 = ui_tmp2 - ui_tmp1;
pCtrl->ui_eng_vmf = ui_tmp3;
#endif
}
char app03_MIA_readHDRPacket(unsigned char *puc_inbuf, // [INPUT] Raw Packet data
unsigned char uc_Hmode) //[INPUT] H mode FLAG
// (return) TRUE
{
int i_cntr; // 繧ｵ繧､繧ｨ繝ｳ繧ｹ繝繧ｿ繧ｫ繧ｦ繝ｳ繧ｿ
unsigned int ui_ti0, ui_ti1;
struct _s_MIA_Product *pDat; //繝励Ο繝繧ｯ繝
struct _s_MIA_CtrlParam *pCtrl; //蛻ｶ蠕｡逕ｨ縺ｮ繝輔Λ繧ｰ蜿翫繝代Λ繝｡繝ｼ繧ｿ
unsigned char *puc_hdr;
unsigned int *pui_TI;
pDat = &Gst_MIA_dat;
pCtrl = &Gst_MIA_ctrl;
if (uc_Hmode) { puc_hdr = pDat->uc_hdrH; pui_TI = &pDat->ui_TIH; }
else { puc_hdr = pDat->uc_hdrL; pui_TI = &pDat->ui_TIL; }
//TI
memcpy(&ui_ti0, puc_inbuf + d_Lcl_MIA_RMP_SIZE, 4); //MISSION繝倥ャ繝縺九ｉ
ui_ti1 = ( (unsigned int) *(puc_inbuf + d_Lcl_MIA_RMP_SIZE +4) << 8) +
( (unsigned int) *(puc_inbuf + d_Lcl_MIA_RMP_SIZE +5) );
//*pui_TI = (!pCtrl->uc_watchman) ? ui_ti0 + ui_ti1 : ui_pcTI;
*pui_TI = ui_ti0 + ui_ti1;
//SCI繝倥ャ繝蜿門ｾ
memcpy(puc_hdr, puc_inbuf + d_Lcl_MIA_SCI_ADRR, d_Lcl_MIA_SCI_SIZE);
//APP03縺ｧ縺ｯENG逕ｨ繝繧ｿ縺ｮ闢ｩ
if (!uc_Hmode) {
//HV info(256繧ｹ繝斐Φ蛻ｒ繝｡繝｢繝ｪ縺ｫ菫晄戟縺吶ｋ)
i_cntr = *(puc_inbuf + d_Lcl_MIA_CNT_ADRR); //繧ｵ繧､繧ｨ繝ｳ繧ｹ繝繧ｿ繧ｫ繧ｦ繝ｳ繧ｿ
memcpy(pDat->uc_HVinf + d_Lcl_MIA_HVB_SIZE*i_cntr, puc_inbuf + d_Lcl_MIA_HVB_ADRR, d_Lcl_MIA_HVB_SIZE);
//ASIC縺ｮ繝繧ｿ
if (pDat->uc_ASIC_idx == 0 && *(puc_inbuf + d_Lcl_MIA_ASC_ADRR) == 0xff //鬆ｭ蜃ｺ縺
&& *(puc_inbuf + d_Lcl_MIA_ASC_ADRR +1) == 0x00
&& *(puc_inbuf + d_Lcl_MIA_ASC_ADRR +2) == 0x55
&& *(puc_inbuf + d_Lcl_MIA_ASC_ADRR +3) == 0xaa)
pDat->uc_ASIC_idx = 1;
else if (pDat->uc_ASIC_idx >= 1) {
memcpy(pDat->uc_ASICinf + d_Lcl_MIA_ASC_SIZE*(pDat->uc_ASIC_idx++ - 1),
puc_inbuf + d_Lcl_MIA_ASC_ADRR, d_Lcl_MIA_ASC_SIZE); }
if (pDat->uc_ASIC_idx == d_Lcl_MIA_ASC_SPNN)//INDEX縺ｮ繝ｪ繧ｻ繝ヨ
pDat->uc_ASIC_idx = 0;
}
return TRUE;
}
//G03uc_data[0xd000] 53248B/(32en x 2B) = 832 cell 縺ｫ繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ繧帝寔繧√ｋ
//M1 [768cell][32en] --> [16sc][16+1][32en](SW) + [16sc][8+1ch][32en](Anti)
//M2 [32sc][32+2ch][32en] (1088 cell) --> [32sc][16+1ch][32en](Anti)
//M3 [16sc][16+2][32en] (288 cell) --> [16sc][8+1][32en](Anti) + [16sc][8ch][32en](SW)
char app03_MIA_readSCIPacket(unsigned char *puc_inbuf, // [INPUT] Raw Packet data
unsigned char *puc_outbuf) // [OUTPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮ縺ｿ蜿悶ｊ蜃ｺ縺
// (return) TRUE
{
int i, j, k;
int i_SegmentNum; // 繧ｻ繧ｰ繝｡繝ｳ繝育分蜿ｷ in 繝溘ャ繧ｷ繝ｧ繝ｳ繝倥ャ繝
int i_modeNo; //繝｢繝ｼ繝臥分蜿ｷ
struct _s_MIA_Product *pDat; //繝励Ο繝繧ｯ繝
unsigned short *pus_cnt0, *pus_cnt1, *pus_cnt2, *pus_cnt3, *pus_cnt4;
pDat = &Gst_MIA_dat;
i_modeNo = pDat->uc_hdrL[8] >> 4 & 0x0f; //(0-2) 繝繧ｿ繝｢繝ｼ繝
i_SegmentNum = *(puc_inbuf + d_Lcl_MIA_SGN_ADRR);
if (i_modeNo == 0) {
if (i_SegmentNum == 0) {//4sc x 18ch x 32en
puc_inbuf += d_Lcl_MIA_SP0_ADRR;
pus_cnt0 = (unsigned short*) (puc_outbuf + d_Lcl_MIA_SW1_ADRR);//Anti-SW
for (j = 0; j < 4; ++j) { //SC0, SC1
for (k = 0; k < 32; ++k) {
for (i = 0; i <= 3; ++i) memcpy(pus_cnt0 + 9*32*j + 32*i + k, puc_inbuf + (j*32*18 + k*18 + i)*2, 2);
memcpy(pus_cnt0 + 9*32*j + 32*8 + k, puc_inbuf + (j*32*18 + k*18 + 4)*2, 2);
for (i = 6; i <= 9; ++i) memcpy(pus_cnt0 + 9*32*j + 32*(i-2) + k, puc_inbuf + (j*32*18 + k*18 + i)*2, 2);
}
}
//##### 2cell -> 1cell ######
pus_cnt0 = (unsigned short*)(puc_outbuf + d_Lcl_MIA_SW1_ADRR); ////Anti-SW from SC0
pus_cnt1 = pus_cnt0 + 9*32*1;
for (i = 0; i < 9*32; ++i) *pus_cnt0++ += *pus_cnt1++; //SC 0
pus_cnt1 = pus_cnt0 + 9*32*1;
pus_cnt2 = pus_cnt0 + 9*32*2;
for (i = 0; i < 9*32; ++i) *pus_cnt0++ = *pus_cnt1++ + *pus_cnt2++; //SC 1
}
else if (i_SegmentNum <= 8) {
puc_inbuf += d_Lcl_MIA_SP1_ADRR;
pus_cnt0 = (unsigned short*) (puc_outbuf) + 17*32*2*(i_SegmentNum - 1);//SW 16x16+1 from SC(i_SegmentNum - 1)x2
for (j = 0; j < 2; ++j) {
for (k = 0; k < 32; ++k) {
for (i = 12; i < 12+16; ++i) memcpy(pus_cnt0 + 17*32*j + 32*(i-12) + k, puc_inbuf + (j*32*30 + k*30 + i)*2, 2);
memcpy(pus_cnt0 + 17*32*j + 32*16 + k, puc_inbuf + (j*32*30 + k*30 + 4)*2, 2);
}
}
pus_cnt0 = (unsigned short*) (puc_outbuf + d_Lcl_MIA_SW1_ADRR) + 9*32*2*i_SegmentNum;//Anti-SW from SC2,4, .., 16
for (j = 0; j < 2; ++j) { //SC0, SC1
for (k = 0; k < 32; ++k) {
for (i = 0; i <= 3; ++i) memcpy(pus_cnt0 + 9*32*j + 32*i + k, puc_inbuf + (j*32*30 + k*30 + i)*2, 2);
memcpy(pus_cnt0 + 9*32*j + 32*8 + k, puc_inbuf + (j*32*30 + k*30 + 4)*2, 2);
for (i = 6; i <= 9; ++i) memcpy(pus_cnt0 + 9*32*j + 32*(i-2) + k, puc_inbuf + (j*32*30 + k*30 + i)*2, 2);
}
}
//##### 4cell -> 1cell ######
if (i_SegmentNum == 8) {
pus_cnt0 = (unsigned short*)(puc_outbuf + d_Lcl_MIA_SW1_ADRR) + 9*32*2; ////Anti-SW from SC2
pus_cnt1 = pus_cnt0 + 9*32*1;
pus_cnt2 = pus_cnt0 + 9*32*2;
pus_cnt3 = pus_cnt0 + 9*32*3;
for (i = 0; i < 9*32; ++i) *pus_cnt0++ += *pus_cnt1++ + *pus_cnt2++ + *pus_cnt3++; //SC 2
pus_cnt1 = pus_cnt0 + 9*32*3;
pus_cnt2 = pus_cnt0 + 9*32*4;
pus_cnt3 = pus_cnt0 + 9*32*5;
pus_cnt4 = pus_cnt0 + 9*32*6;
for (i = 0; i < 9*32; ++i) *pus_cnt0++ = *pus_cnt1++ + *pus_cnt2++ + *pus_cnt3++ + *pus_cnt4++;//SC 3
pus_cnt1 = pus_cnt0 + 9*32*6;
pus_cnt2 = pus_cnt0 + 9*32*7;
pus_cnt3 = pus_cnt0 + 9*32*8;
pus_cnt4 = pus_cnt0 + 9*32*9;
for (i = 0; i < 9*32; ++i) *pus_cnt0++ = *pus_cnt1++ + *pus_cnt2++ + *pus_cnt3++ + *pus_cnt4++;//SC 4
pus_cnt1 = pus_cnt0 + 9*32*9;
pus_cnt2 = pus_cnt0 + 9*32*10;
pus_cnt3 = pus_cnt0 + 9*32*11;
pus_cnt4 = pus_cnt0 + 9*32*12;
for (i = 0; i < 9*32; ++i) *pus_cnt0++ = *pus_cnt1++ + *pus_cnt2++ + *pus_cnt3++ + *pus_cnt4++;//SC 5
}
}
else if (i_SegmentNum == 9) {
puc_inbuf += d_Lcl_MIA_SP1_ADRR;
pus_cnt0 = (unsigned short*) (puc_outbuf + d_Lcl_MIA_SW1_ADRR) + 9*32*6;//Anti-SW from SC6
for (j = 0; j < 4; ++j) { //SC6, SC7
for (k = 0; k < 32; ++k) {
for (i = 0; i <= 3; ++i) memcpy(pus_cnt0 + 9*32*j + 32*i + k, puc_inbuf + (j*32*18 + k*18 + i)*2, 2);
memcpy(pus_cnt0 + 9*32*j + 32*8 + k, puc_inbuf + (j*32*18 + k*18 + 4)*2, 2);
for (i = 6; i <= 9; ++i) memcpy(pus_cnt0 + 9*32*j + 32*(i-2) + k, puc_inbuf + (j*32*18 + k*18 + i)*2, 2);
}
}
//##### 2cell -> 1cell ######
pus_cnt0 = (unsigned short*)(puc_outbuf + d_Lcl_MIA_SW1_ADRR) + 9*32*6; //Anti-SW from SC6
pus_cnt1 = pus_cnt0 + 9*32*1;
for (i = 0; i < 9*32; ++i) *pus_cnt0++ += *pus_cnt1++; //SC 6
pus_cnt1 = pus_cnt0 + 9*32*1;
pus_cnt2 = pus_cnt0 + 9*32*2;
for (i = 0; i < 9*32; ++i) *pus_cnt0++ = *pus_cnt1++ + *pus_cnt2++; //SC 7
}
else if (i_SegmentNum <= 11) {
puc_inbuf += d_Lcl_MIA_SP1_ADRR;
pus_cnt0 = (unsigned short*) (puc_outbuf + d_Lcl_MIA_SW1_ADRR) + 9*32*(8 + (i_SegmentNum-10)*4);//Anti-SW from SC8 or SC12
for (j = 0; j < 4; ++j) { //SC8-11 or SC12-15
for (k = 0; k < 32; ++k) {
for (i = 0; i <= 3; ++i) memcpy(pus_cnt0 + 9*32*j +32*i +k, puc_inbuf + (j*32*18 +k*18 +i)*2, 2);
memcpy(pus_cnt0 + 9*32*j +32*8 +k, puc_inbuf + (j*32*18 +k*18 +4)*2, 2);
for (i = 6; i <= 9; ++i) memcpy(pus_cnt0 + 9*32*j +32*(i-2) +k, puc_inbuf + (j*32*18 +k*18 +i)*2, 2);
}
}
}
else {
return FALSE;
}
}
else if (i_modeNo == 1) { //M2 32sc x (32ch + 2ch) = 1088 cell 縺ｮ縺■17ch蛻ｒ驟咲ｽｮ縺吶ｋ
if (i_SegmentNum <= 15) {
if (!i_SegmentNum) puc_inbuf += d_Lcl_MIA_SP0_ADRR;
else puc_inbuf += d_Lcl_MIA_SP1_ADRR;
pus_cnt0 = (unsigned short*) (puc_outbuf) + 2*17*32*i_SegmentNum;//MG1 from SC(2 x Seg#)
for (j = 0; j < 2; ++j) {
for (k = 0; k < 32; ++k) {
for (i = 0; i <= 7; ++i) memcpy(pus_cnt0 + 17*32*j +32*i +k, puc_inbuf + (j*32*34 +k*34 +i)*2, 2);
memcpy(pus_cnt0 + 17*32*j +32*16 +k, puc_inbuf + (j*32*34 +k*34 +8)*2, 2);
for (i = 10; i <= 17; ++i) memcpy(pus_cnt0 + 17*32*j +32*(i-2) +k, puc_inbuf + (j*32*34 +k*34 +i)*2, 2);
}
}
}
else {
return FALSE;
}
}
else if (i_modeNo == 2) { //M3 16sc x (16ch + 2ch) = 288 cell 縺ｮ縺■16+1ch/272cell繧帝鄂ｮ縺吶ｋ
// 16sc x 8+1ch x 32en + 16sc x 8ch x 32en(for Hmode)
if (i_SegmentNum <= 15) {
if (!i_SegmentNum) puc_inbuf += d_Lcl_MIA_SP0_ADRR;
else puc_inbuf += d_Lcl_MIA_SP1_ADRR;
pus_cnt0 = (unsigned short*) (puc_outbuf) + 9*32*i_SegmentNum; //MG2 from SC(Seg#)
for (k = 0; k < 32; ++k) {
for (i = 0; i <= 3; ++i) memcpy(pus_cnt0 + 32*i + k, puc_inbuf + (k*18 + i)*2, 2);
memcpy(pus_cnt0 + 32*8 + k, puc_inbuf + (k*18 + 4)*2, 2);
for (i = 6; i <= 9; ++i) memcpy(pus_cnt0 + 32*(i-2) + k, puc_inbuf + (k*18 + i)*2, 2);
}
pus_cnt0 = (unsigned short*) (puc_outbuf + d_Lcl_MIA_MG3_ADRR) + 8*32*i_SegmentNum; //SW channel from SC(Seg#)
for (k = 0; k < 32; ++k)
for (i = 10; i < 18; ++i) memcpy(pus_cnt0 + 32*(i-10) + k, puc_inbuf + (k*18 + i)*2, 2);
}
else {
return FALSE;
}
}
else if (i_modeNo == 3) {//Memorydump
return FALSE;
}
else {
return FALSE;
}
return TRUE;
}
void app03_MIA_makeSWcal(unsigned short us_pac[], // [OUTPUT] 繧ｫ繧ｦ繝ｳ繧ｿ繝繧ｿ
unsigned char uc_modeNo) // [INPUT] 繝｢繝ｼ繝臥分蜿ｷ
// (return)
{
int i, j, k;
int i_ch_num[2], i_sc_num;
int i_addr;
struct _s_MIA_CtrlParam *pCtrl; //蛻ｶ蠕｡逕ｨ縺ｮ繝輔Λ繧ｰ蜿翫繝代Λ繝｡繝ｼ繧ｿ
pCtrl = &Gst_MIA_ctrl;
//繧ｫ繧ｦ繝ｳ繧ｿ繝繧ｿ
//M1 [16sc][16+1][32en](SW) + [16sc][8+1ch][32en](Anti)
//M3 [16sc][8+1][32en](Anti) + [16sc][8ch][32en](SW for Hmode)
//M2 [32sc][16+1ch][32en]
if (uc_modeNo == 0) { i_sc_num = 16; i_ch_num[0] = 17; i_ch_num[1] = 9; i_addr = d_Lcl_MIA_SW1_ADRR/2; }
else if (uc_modeNo == 2) { i_sc_num = 16; i_ch_num[0] = 9; i_ch_num[1] = 8; i_addr = d_Lcl_MIA_MG3_ADRR/2; }
else { i_sc_num = 32; i_ch_num[0] = 17; i_ch_num[1] = 0; i_addr = 0; }
for (j = 0; j < i_sc_num; j++) {
for (i = 0; i < i_ch_num[0]; ++i) {
for ( k = 0; k < 32; ++k) {
if ( (j == pCtrl->uc_swcal_prm[3] || pCtrl->uc_swcal_prm[3] == 0xff)
&& (i == pCtrl->uc_swcal_prm[2] || pCtrl->uc_swcal_prm[2] == 0xff)
&& (k == pCtrl->uc_swcal_prm[1] || pCtrl->uc_swcal_prm[1] == 0xff) ) {
if (pCtrl->uc_swcal_prm[4] == 0) us_pac[k + 32*i + 32*i_ch_num[0]*j] = k;
else us_pac[k + 32*i + 32*i_ch_num[0]*j] = pCtrl->uc_swcal_prm[4];
}
else
us_pac[k + 32*i + 32*i_ch_num[0]*j] = 0;
}}}
if (uc_modeNo == 0 || uc_modeNo == 2) {
for (j = 0; j < i_sc_num; j++) {
for (i = 0; i < i_ch_num[1]; ++i) {
for ( k = 0; k < 32; ++k) {
if ( (j == pCtrl->uc_swcal_prm[3] || pCtrl->uc_swcal_prm[3] == 0xff)
&& (i == pCtrl->uc_swcal_prm[2] || pCtrl->uc_swcal_prm[2] == 0xff)
&& (k == pCtrl->uc_swcal_prm[1] || pCtrl->uc_swcal_prm[1] == 0xff) ) {
if (pCtrl->uc_swcal_prm[4] == 0) us_pac[k + 32*i + 32*i_ch_num[1]*j + i_addr] = k;
else us_pac[k + 32*i + 32*i_ch_num[1]*j + i_addr] = pCtrl->uc_swcal_prm[4];
}
else us_pac[k + 32*i + 32*i_ch_num[1]*j + i_addr] = 0;
}}}
}
return;
}
//L繝励Ο繝繧ｯ繝医縲｀IA縺ｮ繝繧ｿ繝｢繝ｼ繝峨°繧我ｸ諢上↓豎ｺ螳壹☆繧
//Guc_MIA_eng_sci: SCI/ENG = 0/1
//Guc_MIA_mode: L繝励Ο繝繧ｯ繝医〒縺ｯ蜿ら縺吶ｋ蠢ｦ√′縺ｪ縺
//Guc_MIA_snapshot_ave; //1:Snapshot, 0:Average
char app03_MIA_makeL(unsigned int ui_sunpulseCnt, // [INPUT] Sun Pulse
unsigned short *pus_inbuf, // [INPUT] COUNT data
unsigned short *pus_outbuf, // [OUTPUT] Product
unsigned short *pus_midbuf) // [MID] buffer for comp
{
int i, j, k, n;
unsigned short *pus_SWCnt, *pus_ALLCnt;
unsigned int *pui_cnt0;
unsigned short *pus_cnt1;
int i_modeNo, i_hvram[8], i_spinNo;
int i_dir;
double f_VM[10];
unsigned int ui_sp_sync;
unsigned char uc_info = 0;
unsigned short us_len = 0;
unsigned short *pus_outb_cur, *pus_outb_cur0;
unsigned char uc_se_mode, uc_Lflg;
struct _s_MIA_Product *pDat; //繝励Ο繝繧ｯ繝
struct _s_MIA_CtrlParam *pCtrl; //蛻ｶ蠕｡逕ｨ縺ｮ繝輔Λ繧ｰ蜿翫繝代Λ繝｡繝ｼ繧ｿ
pDat = &Gst_MIA_dat;
pCtrl = &Gst_MIA_ctrl;
uc_Lflg = 0;
uc_se_mode = pCtrl->uc_snap_ave + pCtrl->uc_eng_sci*2 + (pCtrl->uc_mode << 2 & 0x3c);//SCI/ENG 繝｢繝ｼ繝
//荳贋ｽ阪ン繝ヨ縺九ｉ隱ｭ繧
i_modeNo = (pDat->uc_hdrL[8] >> 4) & 0x0f; //(0-2) 繝繧ｿ繝｢繝ｼ繝
i_spinNo = pDat->uc_hdrL[8] & 0x0f; //(0-3) 繧ｹ繝斐Φ繧ｫ繧ｦ繝ｳ繧ｿ:繧ｨ繝阪Ν繧ｮ繝ｼ繝繝悶Ν蟇ｾ蠢懊↓菴ｿ逕ｨ
//CHECK
if (i_modeNo > 2) i_modeNo = 0; //return (FALSE);
if (i_spinNo > 3) i_spinNo = 0;
for (n = 0; n < 4; ++n) { //RAM逡ｪ蜿ｷ
i_hvram[2*n] = (pDat->uc_hdrL[n + 12] >> 4) & 0x0f;
i_hvram[2*n +1] = pDat->uc_hdrL[n + 12] & 0x0f;
}
for (n = 0; n < 8; ++n) if (i_hvram[n] > 5) i_hvram[n] = 5;
//繧ｹ繝斐Φ繧ｫ繧ｦ繝ｳ繧ｿ縺ｮ邂｡逅 繧ｹ繝斐Φ逡ｪ蜿ｷ縺ｫ蜷梧悄繧貞叙繧
if (i_spinNo == 0 && pDat->us_SPIN_N == 0xffff) pDat->us_SPIN_N = 0;
else if (pDat->us_SPIN_N != 0xffff) pDat->us_SPIN_N++;
else return FALSE; //蜷梧悄縺悟叙繧後◆繧峨繝ｭ繝繧ｯ繝井ｽ懈髢句ｧ
//繝槭Ν繝√せ繝斐Φ繝繧ｿ逕ｨ縺ｮ繧ｫ繧ｦ繝ｳ繧ｿ
ui_sp_sync = pDat->uc_hdrL[6]; //繝繧ｿ蜷梧悄繧ｫ繧ｦ繝ｳ繧ｿ
//ui_sp_sync = ui_sunpulseCnt; //MDP縺九ｉ萓帷ｵｦ縺ｮ繧ｫ繧ｦ繝ｳ繧ｿ
#ifdef _RUN_WITH_EMU_MIA__
ui_sp_sync = pDat->us_SPIN_N; //SW迢ｬ閾ｪ繧ｫ繧ｦ繝ｳ繧ｿ縺ｧ荳頑嶌縺
#endif
pus_outb_cur0 = pus_outb_cur = pus_outbuf + pDat->us_Llen_ttl; //Lmode product
memcpy(pus_outb_cur + 2, pDat->uc_hdrL, d_Lcl_MIA_HK2B*2); pus_outb_cur += 2 + d_Lcl_MIA_HK2B; //HK
pus_ALLCnt = pus_inbuf; //FOR M2 and M3
if (pCtrl->uc_eng_sci == 0) {//繧ｵ繧､繧ｨ繝ｳ繧ｹ
//蛻梵蝎ｨ縺ｮ繝繧ｿ繝｢繝ｼ繝
if (i_modeNo == 0) {
//M1 螟ｪ髯ｽ鬚ｨ
//RAW: [16sc][16+1ch][32en] & [16sc[8+1ch][32en]
//繝励Ο繝繧ｯ繝: VM(4s)[SW, All], VM(16s)[SW], Et(32s)[4dir+SW], 3D-LL(3600s)[SW]
pus_SWCnt = pus_inbuf; //[16sc][16+1ch][32en]
pus_ALLCnt = pus_inbuf + d_Lcl_MIA_SW1_ADRR/2; //[16sc][8+1ch][32en]
//VM(4s) SW
for (n = 0; n < 10; ++n) f_VM[n] = 0.; //蛻晄悄蛹
app03_MIA_CalcVM(8, //[INPUT] HVram縺ｮ荳ｭ縺ｮ繧ｻ繧ｯ繧ｿ繝ｼ謨ｰｼ售W荳ｭ縺ｪ縺ｮ縺ｧ8
16, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮsector謨ｰ
16, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮchannel謨ｰ
32, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮenergy謨ｰ
i_hvram, //[INPUT] HVram [8]
i_spinNo, //[INPUT] SPIN NUMBER 0-3
0, //[INPUT] VM縺ｮ遞ｮ鬘 VMsw-M1(0); VMal-M1(1); VM-M2(2); VM-M3(1)
pus_SWCnt, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ(蜈磯ｭ繧｢繝峨Ξ繧ｹ)
f_VM); //[OUTPUT] Velocity moment
app03_MIA_DBLtoUSHORT(f_VM, pus_outb_cur, 10); pus_outb_cur += 10; //TLM逕ｨ繝代こ繝ヨ縺ｫ驟咲ｽｮ
#ifdef _RUN_ON_WINDOWS_
printf("VMsw(4s): ");
for (n = 0; n < 10; ++n) printf("%.3e ", f_VM[n]);
printf("ﾂ･n");
printf("VMsw(4s): nV/n");
for (n = 1; n <=3 ; ++n) printf("%.3e ", f_VM[n]/f_VM[0]*0xffff);
printf("| %.3e ", app_math_sqrt((f_VM[1]*f_VM[1]+f_VM[2]*f_VM[2]+f_VM[3]*f_VM[3]))/f_VM[0]*0xffff);
printf("ﾂ･n");
#endif
//VM(4s) ALL
for (n = 0; n < 10; ++n) f_VM[n] = 0.; //蛻晄悄蛹
app03_MIA_CalcVM(2, //[INPUT] HVram縺ｮ荳ｭ縺ｮ繧ｻ繧ｯ繧ｿ繝ｼ謨ｰ
16, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮsector謨ｰ
8, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮchannel謨ｰ
32, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮenergy謨ｰ
i_hvram, //[INPUT] HVram [8]
i_spinNo, //[INPUT] SPIN NUMBER 0-3
1, //[INPUT] VM縺ｮ遞ｮ鬘 VMsw-M1(0); VMal-M1(1); VM-M2(2); VM-M3(1)
pus_ALLCnt, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ(蜈磯ｭ繧｢繝峨Ξ繧ｹ)
f_VM); //[OUTPUT] Velocity moment
app03_MIA_DBLtoUSHORT(f_VM, pus_outb_cur, 10); pus_outb_cur += 10; //TLM逕ｨ繝代こ繝ヨ縺ｫ驟咲ｽｮ
#ifdef _RUN_ON_WINDOWS_
VMcal( 2, //[INPUT] HVram縺ｮ荳ｭ縺ｮ繧ｻ繧ｯ繧ｿ繝ｼ謨ｰ
16, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮsector謨ｰ
8, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮchannel謨ｰ
32, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮenergy謨ｰ
i_hvram, //[INPUT] HVram [8]
i_spinNo, //[INPUT] SPIN NUMBER 0-3
1, //[INPUT] VM縺ｮ遞ｮ鬘 VMsw-M1(0); VMal-M1(1); VM-M2(2); VM-M3(1)
pus_ALLCnt, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ(蜈磯ｭ繧｢繝峨Ξ繧ｹ)
my_double); //[OUTPUT] Velocity moment
printf("VMal(4s):@DBL ");
for (n = 0; n < 10; ++n) printf("%.3e ", my_double[n]);
printf("ﾂ･n");
printf("VMal(4s): ");
for (n = 0; n < 10; ++n) printf("%.3e ", f_VM[n]);
printf("ﾂ･n");
printf("VMal(4s): nV/n");
for (n = 1; n <=3 ; ++n) printf("%.3e ", f_VM[n]/f_VM[0]*0xffff);
printf("| %.3e ", app_math_sqrt((f_VM[1]*f_VM[1]+f_VM[2]*f_VM[2]+f_VM[3]*f_VM[3]))/f_VM[0]*0xffff);
printf("ﾂ･n");
app03_MIA_DBLtoUSHORT(f_VM, my_ushort, 10);
printf("VMal(4s): ");
for (n = 0; n < 10; ++n) printf("%04x ", my_ushort[n]);
printf("ﾂ･n");
USHORTtoDBL(my_double, my_ushort, 10);
printf("VMal(4s): ");
for (n = 0; n < 10; ++n) printf("%.3e ", my_double[n]);
printf("ﾂ･n");
#endif
//Et(32s)
if ((ui_sp_sync & 0x07) == 0) {//1st/8 蛻晄悄蛹
pui_cnt0 = pDat->ui_Et;
for (n = 0; n < 5*128; ++n) *pui_cnt0++ = 0;//蛻晄悄蛹
}
if (!pCtrl->uc_snap_ave || !(ui_sp_sync & 0x04)) {//AVERAGE繝｢繝ｼ繝画凾 or 1-4th/8
//Et-SW(32s)
for (j = 0; j < 16; ++j) {
for (i = 0; i < 16; ++i) {
//i_cell = i + 17*j;
pui_cnt0 = &pDat->ui_Et[32*i_spinNo];
pus_cnt1 = pus_SWCnt + (i + 17*j)*32;
for (k = 0; k < 32; ++k) *pui_cnt0++ += *pus_cnt1++;
}}
//Et-ALL(32s)
for (j = 0; j < 16; ++j) {
i_dir = (j+2)/4 + 1; //Et縺ｮ譁ｹ隗堤分蜿ｷ
if (i_dir > 4) i_dir = 1;
for (i = 0; i < 8; ++i) {
//i_cell = i + 9*j;
pui_cnt0 = &(pDat->ui_Et[32*i_spinNo + 128*i_dir]);
pus_cnt1 = pus_ALLCnt + (i + 9*j)*32;
for (k = 0; k < 32; ++k) *pui_cnt0++ += *pus_cnt1++;
}
}
}
if (((ui_sp_sync & 0x07) == 3 && pCtrl->uc_snap_ave) || //4th/4@SNAPSHOT
((ui_sp_sync & 0x07) == 7 && !pCtrl->uc_snap_ave) ) { //8th/8@AVERAGE TLM縺ｫ驟咲ｽｮ
//app03_MIA_UINTtoUSHORT(pDat->ui_Et, pus_outbuf + d_Lcl_MIA_HK2B + 20 + uc_Lflg[0]*10, 128*5);
app04_ENA_Lin2Log(pDat->ui_Et, (unsigned char *)pus_outb_cur, 128*5*4, 0, 0);
uc_Lflg = 1;//繝繧ｿ譛峨ヵ繝ｩ繧ｰ
#ifdef _RUN_ON_WINDOWS_
printf("Et(32s): ﾂ･n");
for (n = 0; n < 128*5; ++n) {
printf("%d ", pDat->ui_Et[n]);
if (n%32 == 31) printf("ﾂ･n");
}
#endif
}
us_len = 2 + d_Lcl_MIA_HK2B + 20 + uc_Lflg*320;//繝繧ｿ髟ｷ
pDat->us_Llen_ttl += us_len;
uc_info = uc_Lflg*0x10;
}
else if (i_modeNo == 1) {
//M2 逎∵ｰ怜恟(鬮伜隗｣)
//繝励Ο繝繧ｯ繝: Et(4s)[4dir x 16en], VM(4s)
//pus_ALLCnt = pus_inbuf;
//Et(4s)
pui_cnt0 = pDat->ui_Et;
for (n = 0; n < 4*32; ++n) *pui_cnt0++ = 0;//蛻晄悄蛹
for (j = 0; j < 32; ++j) {
i_dir = (j+4)/8; //Et縺ｮ譁ｹ隗堤分蜿ｷ
if (i_dir > 3) i_dir = 0;
for (i = 0; i < 16; ++i) {
//pui_cnt0 = &(pDat->ui_Et[32*i_dir]);
//pus_cnt1 = pus_ALLCnt + (i + 17*j)*32;
//for (k = 0; k < 32; ++k) *pui_cnt0++ += *pus_cnt1++;
//Estep縺ｮ蜑榊濠縺ｯ謐ｨ縺ｦ繧九∝ｾ悟濠縺ｮ縺ｿ
pui_cnt0 = &(pDat->ui_Et[16*i_dir]);
pus_cnt1 = pus_ALLCnt + (i + 17*j)*32 + 16;
for (k = 0; k < 16; ++k) *pui_cnt0++ += *pus_cnt1++;
}}
//VM(4s)
for (n = 0; n < 10; ++n) f_VM[n] = 0.; //0.; //蛻晄悄蛹
app03_MIA_CalcVM(4, //[INPUT] HVram縺ｮ荳ｭ縺ｮ繧ｻ繧ｯ繧ｿ繝ｼ謨ｰ
32, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮsector謨ｰ
16, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮchannel謨ｰ
32, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮenergy謨ｰ
i_hvram, //[INPUT] HVram [8]
i_spinNo, //[INPUT] SPIN NUMBER 0-3
2, //[INPUT] VM縺ｮ遞ｮ鬘 VMsw-M1(0); VMal-M1(1); VM-M2(2); VM-M3(1)
pus_ALLCnt, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ(蜈磯ｭ繧｢繝峨Ξ繧ｹ)
f_VM); //[OUTPUT] Velocity moment
//TLM逕ｨ繝代こ繝ヨ縺ｫ驟咲ｽｮ(8-81)
app03_MIA_DBLtoUSHORT(f_VM, pus_outb_cur, 10); pus_outb_cur += 10;
//app03_MIA_UINTtoUSHORT(&(pDat->ui_Et[0]), pus_outbuf + d_Lcl_MIA_HK2B + 10, 4*32);
app04_ENA_Lin2Log(pDat->ui_Et, (unsigned char *)pus_outb_cur, 4*16*4, 0, 0); pus_outb_cur += 32;
//app04_ENA_Lin2Log(pDat->ui_Et, (unsigned char *)pus_outb_cur, 4*32*4, 0, 0); pus_outb_cur += 64;
#ifdef _RUN_ON_WINDOWS_
VMcal( 4, //[INPUT] HVram縺ｮ荳ｭ縺ｮ繧ｻ繧ｯ繧ｿ繝ｼ謨ｰ
32, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮsector謨ｰ
16, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮchannel謨ｰ
32, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮenergy謨ｰ
i_hvram, //[INPUT] HVram [8]
i_spinNo, //[INPUT] SPIN NUMBER 0-3
2, //[INPUT] VM縺ｮ遞ｮ鬘 VMsw-M1(0); VMal-M1(1); VM-M2(2); VM-M3(1)
pus_ALLCnt, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ(蜈磯ｭ繧｢繝峨Ξ繧ｹ)
my_double); //[OUTPUT] Velocity moment
printf("VMal(4s):@DBL ");
for (n = 0; n < 10; ++n) printf("%.3e ", my_double[n]);
printf("ﾂ･n");
printf("VMal(4s): ");
for (n = 0; n < 10; ++n) printf("%.3e ", f_VM[n]);
printf("ﾂ･n");
printf("VMal(4s): nV/n");
for (n = 1; n <=3 ; ++n) printf("%.3e ", f_VM[n]/f_VM[0]*0xffff);
printf("| %.3e ", app_math_sqrt((f_VM[1]*f_VM[1]+f_VM[2]*f_VM[2]+f_VM[3]*f_VM[3]))/f_VM[0]*0xffff);
printf("ﾂ･n");
app03_MIA_DBLtoUSHORT(f_VM, my_ushort, 10);
printf("VMal(4s): ");
for (n = 0; n < 10; ++n) printf("%04x ", my_ushort[n]);
printf("ﾂ･n");
USHORTtoDBL(my_double, my_ushort, 10);
printf("VMal(4s): ");
for (n = 0; n < 10; ++n) printf("%.3e ", my_double[n]);
printf("ﾂ･n");
#endif
us_len = 2 + d_Lcl_MIA_HK2B + 10 + 32;//繝繧ｿ髟ｷ
if (pCtrl->uc_mode < 0x0e || (pDat->us_SPIN_N & 1)) //0x0e 0x0f 迚ｹ谿翫Δ繝ｼ繝峨1/2縺ｧ繝繧ｿ繧帝俣蠑輔￥
pDat->us_Llen_ttl += us_len;
uc_info = 1;
}
else if (i_modeNo == 2) {
//M3 逎∵ｰ怜恟(菴主隗｣)
//繝励Ο繝繧ｯ繝: Et(4s)[4dir x 16en], VM(4s)
//pus_ALLCnt = pus_inbuf;
//Et(4s)
pui_cnt0 = pDat->ui_Et;
for (n = 0; n < 4*32; ++n) *pui_cnt0++ = 0;//蛻晄悄蛹
for (j = 0; j < 16; ++j) {
i_dir = (j+2)/4; //Et縺ｮ譁ｹ隗堤分蜿ｷ
if (i_dir > 3) i_dir = 0;
for (i = 0; i < 8; ++i) {
//pui_cnt0 = &(pDat->ui_Et[32*i_dir]);
//pus_cnt1 = pus_ALLCnt + (i + 9*j)*32;
//for (k = 0; k < 32; ++k) *pui_cnt0++ += *pus_cnt1++;
//Estep縺ｮ蜑榊濠縺ｯ謐ｨ縺ｦ繧九∝ｾ悟濠縺ｮ縺ｿ
pui_cnt0 = &(pDat->ui_Et[16*i_dir]);
pus_cnt1 = pus_ALLCnt + (i + 9*j)*32 + 16;
for (k = 0; k < 16; ++k) *pui_cnt0++ += *pus_cnt1++;
}}
//VM(4s)
for (n = 0; n < 10; ++n) f_VM[n] = 0.;//0.; //蛻晄悄蛹
app03_MIA_CalcVM(2, //[INPUT] HVram縺ｮ荳ｭ縺ｮ繧ｻ繧ｯ繧ｿ繝ｼ謨ｰ
16, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮsector謨ｰ
8, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮchannel謨ｰ
32, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮenergy謨ｰ
i_hvram, //[INPUT] HVram [8]
i_spinNo, //[INPUT] SPIN NUMBER 0-3
1, //[INPUT] VM縺ｮ遞ｮ鬘 VMsw-M1(0); VMal-M1(1); VM-M2(2); VM-M3(1)
pus_ALLCnt, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ(蜈磯ｭ繧｢繝峨Ξ繧ｹ)
f_VM); //[OUTPUT] Velocity moment
//TLM逕ｨ繝代こ繝ヨ縺ｫ驟咲ｽｮ(8-81)
app03_MIA_DBLtoUSHORT(f_VM, pus_outb_cur, 10); pus_outb_cur += 10;
//app03_MIA_UINTtoUSHORT(pDat->ui_Et, pus_outbuf + d_Lcl_MIA_HK2B + 10, 4*32);
app04_ENA_Lin2Log(pDat->ui_Et, (unsigned char *)pus_outb_cur, 4*16*4, 0, 0); pus_outb_cur += 32;
//app04_ENA_Lin2Log(pDat->ui_Et, (unsigned char *)pus_outb_cur, 4*32*4, 0, 0); pus_outb_cur += 64;
#ifdef _RUN_ON_WINDOWS_
VMcal( 2, //[INPUT] HVram縺ｮ荳ｭ縺ｮ繧ｻ繧ｯ繧ｿ繝ｼ謨ｰ
16, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮsector謨ｰ
8, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮchannel謨ｰ
32, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮenergy謨ｰ
i_hvram, //[INPUT] HVram [8]
i_spinNo, //[INPUT] SPIN NUMBER 0-3
1, //[INPUT] VM縺ｮ遞ｮ鬘 VMsw-M1(0); VMal-M1(1); VM-M2(2); VM-M3(1)
pus_ALLCnt, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ(蜈磯ｭ繧｢繝峨Ξ繧ｹ)
my_double); //[OUTPUT] Velocity moment
//printf("VMal(4s):@DBL ");
//for (n = 0; n < 10; ++n) printf("%.3e ", my_double[n]);
//printf("ﾂ･n");
printf("VMal(4s): ");
for (n = 0; n < 10; ++n) printf("%.3e ", f_VM[n]);
printf("ﾂ･n");
printf("VMal(4s): nV/n");
for (n = 1; n <=3 ; ++n) printf("%.3e ", f_VM[n]/f_VM[0]*0xffff);
printf("| %.3e ", app_math_sqrt((f_VM[1]*f_VM[1]+f_VM[2]*f_VM[2]+f_VM[3]*f_VM[3]))/f_VM[0]*0xffff);
printf("ﾂ･n");
app03_MIA_DBLtoUSHORT(f_VM, my_ushort, 10);
printf("VMal(4s): ");
for (n = 0; n < 10; ++n) printf("%04x ", my_ushort[n]);
printf("ﾂ･n");
USHORTtoDBL(my_double, my_ushort, 10);
printf("VMal(4s): ");
for (n = 0; n < 10; ++n) printf("%.3e ", my_double[n]);
printf("ﾂ･n");
printf("Et(4s):ﾂ･n");
for (n = 0; n < 4*32; ++n) printf("%04x ", pDat->ui_Et[n]);
printf("ﾂ･n");
#endif
us_len = 2 + d_Lcl_MIA_HK2B + 10 + 32;//繝繧ｿ髟ｷ
if (pCtrl->uc_mode < 0x0e || (pDat->us_SPIN_N & 1)) //0x0e 0x0f 迚ｹ谿翫Δ繝ｼ繝峨1/2縺ｧ繝繧ｿ繧帝俣蠑輔￥
pDat->us_Llen_ttl += us_len;
uc_info = 2;
}
else {
us_len = 2 + d_Lcl_MIA_HK2B;
pDat->us_Llen_ttl += us_len;
uc_info = 4;
//繝代こ繝ヨ縺ｮ蜈磯ｭ荳驛ｨ
}
// ### SHARED DATA ###
/* ***** comment out by YK *****
for (i = 0; i < Gd_TRG_MAX; ++i) if (Gui_TRG1_SpTI_s[i] <= ui_TI ) break; // pDat->ui_TIL
if (i < Gd_TRG_MAX) {
*/
i = app_tiTrgSearch ( pDat->ui_TIL, Gd_N_MIA ); // **** REV by Y.K. 121125 ****
if (i) { // **** REV by Y.K. 121125 ****
Gus_TRG1_MIA_N[i] = (unsigned short)(f_VM[0]);
if (f_VM[0] > 0) {
Gs_TRG1_MIA_Vx[i] = (short)(f_VM[1]/f_VM[0]*0xfff);
Gs_TRG1_MIA_Vy[i] = (short)(f_VM[2]/f_VM[0]*0xfff);
Gs_TRG1_MIA_Vz[i] = (short)(f_VM[3]/f_VM[0]*0xfff);
Gus_TRG1_MIA_T[i] = (unsigned short)( (f_VM[4] + f_VM[5] + f_VM[6])/f_VM[0]*0xfff);
}
else {
Gs_TRG1_MIA_Vx[i] = 0;
Gs_TRG1_MIA_Vy[i] = 0;
Gs_TRG1_MIA_Vz[i] = 0;
Gus_TRG1_MIA_T[i] = 0;
}
for (j = 0; j < 7; ++j) Guc_TRG1_MIA_Esp[i][j] = (unsigned char)(pDat->ui_Et[j*2]/0xffffff);
}
}
//###################### 繧ｨ繝ｳ繧ｸ繝九い繝ｪ繝ｳ繧ｰ繝｢繝ｼ繝 ########################
else if (pCtrl->uc_eng_sci == 1) {
//繝励Ο繝繧ｯ繝: SCI(28B), HV(24B)
n = pDat->uc_hdrL[6]; //繧ｵ繧､繧ｨ繝ｳ繧ｹ繝繧ｿ繧ｫ繧ｦ繝ｳ繧ｿ
memcpy(pus_outb_cur, pDat->uc_HVinf + d_Lcl_MIA_HVB_SIZE*n, d_Lcl_MIA_HVB_SIZE);//HV bulk AD packet
//繝繧ｿ髟ｷ
us_len = 2 + d_Lcl_MIA_HK2B + d_Lcl_MIA_HVB_SIZE/2;
pDat->us_Llen_ttl += us_len;
uc_info = 3; //繧ｳ繝｡繝ｳ繝 INFO
}
else {
us_len = 2 + d_Lcl_MIA_HK2B;
pDat->us_Llen_ttl += us_len;
uc_info = 5;
//繝代こ繝ヨ縺ｮ蜈磯ｭ荳驛ｨ
}
//蜈磯ｭ2B蜈･蜉
*pus_outb_cur0++ = uc_se_mode*0x100 + uc_info; //MPPE mode + MDPinfo
*pus_outb_cur0 = us_len*2; //繝繧ｿ髟ｷ
//TLM蜃ｺ蜉
if (pDat->us_SPIN_N%16 == 15 || pDat->us_Llen_ttl > 1500) { //16th spin or > 3kB
app03_MIA_tlmout(Gd_N_MIA, //[INPUT] sensor ID
pCtrl->uc_vet_cmp_ena, //[INPUT] 蝨ｧ邵ｮ繝輔Λ繧ｰ
pDat->us_Llen_ttl, //[INPUT] data髟ｷ縺
uc_se_mode + 0x40, //[INPUT] Comment2
uc_info, //[INPUT] Comment3
pus_outbuf, //[INPUT] 蝨ｧ邵ｮ蜑阪繝励Ο繝繧ｯ繝
pus_midbuf, //[MID] 蝨ｧ邵ｮ蠕後ヰ繝ヵ繧｡
pDat->ui_TIL, //[INPUT] TI
0); //[INPUT] 繝輔Λ繧ｰ縲0:L, 1: M, 4-9:H(DR-ID縺ｫ縺昴縺ｾ縺ｾ菴ｿ縺)
pDat->us_Llen_ttl = 0;
}
//3D-LL-M1 SW 900spin縺ｫ1蝗
if (pDat->us_SPIN_N == d_Lcl_MIA_3DLL && pCtrl->uc_eng_sci == 0) {
memcpy(G03uc_data, pDat->uc_hdrL, 4); //TI 4B
//8kB莉･荳翫↑縺ｮ縺ｧ4蛻牡
if (i_modeNo == 0) { us_len = 4*17*32 +2; n = 4; uc_info = 4;}
else if (i_modeNo == 1) { us_len = 4*17*32 +2; n = 4; uc_info = 5;}
else if (i_modeNo == 2) { us_len = 8*9*32 +2; n = 2; uc_info = 6;}
else { us_len = 0; n = 0;}
pus_cnt1 = (unsigned short*)G03uc_data;
for (i = 0; i < n; ++i) {
app03_MIA_tlmout(Gd_N_MIA, //[INPUT] sensor ID
pCtrl->uc_vet_cmp_ena, //[INPUT] 蝨ｧ邵ｮ繝輔Λ繧ｰ
us_len, //[INPUT] data髟ｷ縺
uc_se_mode, //[INPUT] Comment2
uc_info + i*0x10, //[INPUT] Comment3
pus_cnt1 + us_len*i, //[INPUT] 蝨ｧ邵ｮ蜑阪繝励Ο繝繧ｯ繝
pus_midbuf, //[MID] 蝨ｧ邵ｮ蠕後ヰ繝ヵ繧｡
pDat->ui_TIL, //[INPUT] TI
0); //[INPUT] 繝輔Λ繧ｰ縲0:L, 1: M, 4-9:H(DR-ID縺ｫ縺昴縺ｾ縺ｾ菴ｿ縺)
if(i == 0) us_len -= 2;
}
if (i_modeNo == 1) memcpy(pDat->us_3DLL, pus_ALLCnt + 16*17*32, 16*17*32*2); //蜊雁繧剃ｿ晏ｭ
//#ifdef _RUN_ON_WINDOWS_
//printf("3D-LL-M1: ﾂ･n");
//for (n = 0; n < 16*17*32; ++n) {
// printf("%d ", *pus_SWCnt++);
// if (n%32 == 31) printf("ﾂ･n");
//}
//#endif
}
else if (pDat->us_SPIN_N == d_Lcl_MIA_3DLL + 1 && pCtrl->uc_eng_sci == 0 && i_modeNo == 1) {
//谿九ｊ蜊雁TLM 4蛻牡
for (i = 0; i < 4; ++i)
app03_MIA_tlmout(Gd_N_MIA, //[INPUT] sensor ID
pCtrl->uc_vet_cmp_ena, //[INPUT] 蝨ｧ邵ｮ繝輔Λ繧ｰ
4*17*32, //[INPUT] data髟ｷ縺
uc_se_mode, //[INPUT] Comment2
5 + (i+4)*0x10, //[INPUT] Comment3
pDat->us_3DLL + 4*17*32*i,//[INPUT] 蝨ｧ邵ｮ蜑阪繝励Ο繝繧ｯ繝
pus_midbuf, //[MID] 蝨ｧ邵ｮ蠕後ヰ繝ヵ繧｡
pDat->ui_TIL, //[INPUT] TI
0); //[INPUT] 繝輔Λ繧ｰ縲0:L, 1: M, 4-9:H(DR-ID縺ｫ縺昴縺ｾ縺ｾ菴ｿ縺)
}
//繧ｫ繧ｦ繝ｳ繧ｿ繧偵Μ繧ｻ繝ヨ M3(640s) or M1-2(3600s)
if (pDat->us_SPIN_N >= 159 && i_modeNo == 2 && (pDat->us_SPIN_N & 1) ) pDat->us_SPIN_N = 0xffff;
if (pDat->us_SPIN_N == 899) pDat->us_SPIN_N = 0xffff;
return (TRUE);
}
int app03_MIA_GetVelcity( int i_ram, //[INPUT] HV RAM NUMBER 0-5
int i_spinNo) //[INPUT] SPIN NUMBER 0-3
//return : Address of Velocity packet
{
int i_eng;
if (i_ram == 0) i_eng = 32*i_spinNo; //T0
else if (i_ram == 1) i_eng = 32*i_spinNo + 128; //T1
else if (i_ram == 2) i_eng = 32*(i_spinNo & 0x01) + 128*2; //T2
else if (i_ram == 3) i_eng = 128*2 + 64; //T3
else if (i_ram == 4) i_eng = 128*2 + 64 + 32; //T4
else if (i_ram == 5) i_eng = 128*2 + 64 + 32*2; //T5
else i_eng = 0; //萓句､門逅
return i_eng;
}
char app03_MIA_CalcVM( int i_Dsc, //[INPUT] HVram縺ｮ荳ｭ縺ｮ繧ｻ繧ｯ繧ｿ繝ｼ謨ｰ
int i_num_sc, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮsector謨ｰ
int i_num_ch, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮchannel謨ｰ
int i_num_en, //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ縺ｮenergy謨ｰ
int i_HVram[], //[INPUT] HVram [8]
int i_spinNo, //[INPUT] SPIN NUMBER 0-3
int i_VMMode, //[INPUT] VM縺ｮ遞ｮ鬘 VMsw-M1(0); VMal-M1(1); VM-M2(2); VM-M3(1)
unsigned short us_cnt[], //[INPUT] 繧ｫ繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ(蜈磯ｭ繧｢繝峨Ξ繧ｹ)
double f_VM[]) //[OUTPUT] Velocity moment
{
int i, j, k, n;
int i_cell, i_c, i_cs, i_n, i_sp, i_eng;
double f_VMt[3];
double f_vtb;
int i_prmaddr;
int i_ram_offset;
unsigned char ucf[32];
struct _s_MIA_ProcParam *pP; //隗｣譫千畑繝代Λ繝｡繝ｼ繧ｿ
struct _s_MIA_CtrlParam *pCtrl; //蛻ｶ蠕｡逕ｨ縺ｮ繝輔Λ繧ｰ蜿翫繝代Λ繝｡繝ｼ繧ｿ
pCtrl = &Gst_MIA_ctrl;
pP = &Gst_MIA_proc;
//Energy step 菴ｿ逕ｨ繝ｻ譛ｪ菴ｿ逕ｨ縺ｮ繝輔Λ繧ｰ
for (k = 0; k < 32; ++k) ucf[k] = pCtrl->ui_eng_vmf >> k & 0x01;
//i_ram_offset: SW譎ゅ繧ｻ繧ｯ繧ｿ繝ｼ縺碁比ｸｭ縺九ｉ蟋九∪繧九縺ｧOFFSET繧偵▽縺代ｋ
//i_prmaddr: gf繝繝悶Ν縺ｪ縺ｩ縺ｮ髢句ｧ九い繝峨Ξ繧ｹ
if (i_VMMode == 0) { i_prmaddr = 0; i_ram_offset = 1; }
else if (i_VMMode == 1) { i_prmaddr = 16*2; i_ram_offset = 0; }
else if (i_VMMode == 2) { i_prmaddr = 16*2 + 8*2; i_ram_offset = 0; }
else { i_prmaddr = 0; i_ram_offset = 0; }
for (j = 0; j < i_num_sc; ++j) {
//HV Sweep Type T0-5
i_eng = app03_MIA_GetVelcity(i_HVram[j/i_Dsc + i_ram_offset], i_spinNo);
//繧ｹ繝昴う繝ｩ繝ｼ T1縺ｮ縺ｨ縺阪縺ｿON
if (i_HVram[j/i_Dsc + i_ram_offset] == 1) i_sp = 1;
else i_sp = 0;
for (i = 0; i < i_num_ch; ++i) {
i_cell = i + j*(i_num_ch + 1);
i_c = i + i_sp*i_num_ch + i_prmaddr;
i_cs = i + j*i_num_ch + i_sp*i_num_ch*i_num_sc + i_prmaddr*16;
for (n = 0; n < 3; ++n) f_VMt[n] = 0.; //蛻晄悄蛹
for (k = 0; k < i_num_en; ++k) {
if (!pP->us_vlc[k +i_eng] ||!ucf[k]) continue; //0蜑ｲ縲〃繝繝悶Ν荳堺ｽｿ逕ｨFLG譎ゅ繧ｹ繧ｭ繝
i_n = i_cell*i_num_en + k;
f_VMt[0] += (double)us_cnt[i_n]/pP->us_vlc[k +i_eng];
f_VMt[1] += (double)us_cnt[i_n];
f_VMt[2] += (double)us_cnt[i_n]*pP->us_vlc[k +i_eng];
}
f_vtb = (double)pP->us_gf[i_c]*pP->s_csp[i_c];
f_VMt[0] *= f_vtb/(d_LCl_MIA_TBL_VF0 + pP->uc_vf[i_c]);
f_VMt[1] *= f_vtb;
f_VMt[2] *= f_vtb*(d_LCl_MIA_TBL_VF0 + pP->uc_vf[i_c]);
f_VM[0] += f_VMt[0];
f_VM[1] += f_VMt[1]*pP->s_csp[i_c] *pP->s_csa[i_cs];
f_VM[2] += f_VMt[1]*pP->s_csp[i_c] *pP->s_sna[i_cs];
f_VM[3] += f_VMt[1]*pP->s_snp[i_c];
f_VM[4] += f_VMt[2]*pP->s_csp[i_c]*pP->s_csp[i_c]*pP->s_csa[i_cs]*pP->s_csa[i_cs];
f_VM[5] += f_VMt[2]*pP->s_csp[i_c]*pP->s_csp[i_c]*pP->s_sna[i_cs]*pP->s_sna[i_cs];
f_VM[6] += f_VMt[2]*pP->s_snp[i_c]*pP->s_snp[i_c];
f_VM[7] += f_VMt[2]*pP->s_csp[i_c]*pP->s_csp[i_c]*pP->s_csa[i_cs]*pP->s_sna[i_cs];
f_VM[8] += f_VMt[2]*pP->s_csp[i_c]*pP->s_snp[i_c]*pP->s_sna[i_cs];
f_VM[9] += f_VMt[2]*pP->s_csp[i_c]*pP->s_snp[i_c]*pP->s_csa[i_cs];
}
}
f_VM[0] /= d_Lcl_MIA_N_NRM;
f_VM[1] /= d_Lcl_MIA_V3_NRM;
f_VM[2] /= d_Lcl_MIA_V3_NRM;
f_VM[3] /= d_Lcl_MIA_V2_NRM;
f_VM[4] /= d_Lcl_MIA_P5_NRM;
f_VM[5] /= d_Lcl_MIA_P5_NRM;
f_VM[6] /= d_Lcl_MIA_P3_NRM;
f_VM[7] /= d_Lcl_MIA_P5_NRM;
f_VM[8] /= d_Lcl_MIA_P4_NRM;
f_VM[9] /= d_Lcl_MIA_P4_NRM;
return TRUE;
}
char app03_MIA_makeM(unsigned int ui_sunpulseCnt, // [INPUT] Sun Pulse
unsigned short *pus_inbuf, // [INPUT] COUNT data
unsigned short *pus_outbuf, // [OUTPUT] Product
unsigned short *pus_midbuf) // [MID] buffer for comp
{
int i, k;
int i_modeNo, i_spinNo;
unsigned short *pus_cnt0, *pus_cnt1;
unsigned short *pus_ALLCnt; //, *pus_SWCnt;
unsigned int ui_sp_sync;
unsigned char uc_se_mode, uc_info; //->TLM
unsigned short us_Mlen = 0;
struct _s_MIA_Product *pDat; //繝励Ο繝繧ｯ繝
struct _s_MIA_CtrlParam *pCtrl; //蛻ｶ蠕｡逕ｨ縺ｮ繝輔Λ繧ｰ蜿翫繝代Λ繝｡繝ｼ繧ｿ
pDat = &Gst_MIA_dat;
pCtrl = &Gst_MIA_ctrl;
//荳贋ｽ阪ン繝ヨ縺九ｉ隱ｭ繧
i_modeNo = (pDat->uc_hdrL[8] >> 4) & 0x0f; //(0-2) 繝繧ｿ繝｢繝ｼ繝
i_spinNo = pDat->uc_hdrL[8] & 0x0f; //(0-3) 繧ｹ繝斐Φ繧ｫ繧ｦ繝ｳ繧ｿ:繧ｨ繝阪Ν繧ｮ繝ｼ繝繝悶Ν蟇ｾ蠢懊↓菴ｿ逕ｨ
//CHECK
if (i_modeNo > 2) i_modeNo = 0; //return (FALSE);
if (i_spinNo > 3) i_spinNo = 0;
//HK(SCI hdr) and TI
memcpy(pus_outbuf, pDat->uc_hdrL, d_Lcl_MIA_HK2B*2); //HK
//繝槭Ν繝√せ繝斐Φ繝繧ｿ逕ｨ縺ｮ繧ｫ繧ｦ繝ｳ繧ｿ
ui_sp_sync = pDat->uc_hdrL[6]; //繝繧ｿ蜷梧悄繧ｫ繧ｦ繝ｳ繧ｿ
//ui_sp_sync = sunpulseCnt; //MDP縺九ｉ萓帷ｵｦ縺ｮ繧ｫ繧ｦ繝ｳ繧ｿ
//SCI/ENG 繝｢繝ｼ繝 -> TLM
uc_se_mode = pCtrl->uc_snap_ave + pCtrl->uc_eng_sci*2 + (pCtrl->uc_mode << 2 & 0x3c);
uc_info = 0;
// M-mode Data
if (pCtrl->uc_eng_sci == 0) {//繧ｵ繧､繧ｨ繝ｳ繧ｹ繝｢繝ｼ繝
//蛻梵蝎ｨ縺ｮ繝繧ｿ繝｢繝ｼ繝
if (i_modeNo == 0) {
//M1 螟ｪ髯ｽ鬚ｨ
//pus_SWCnt = pus_inbuf; //[16sc][16+1ch][32en]
pus_ALLCnt = pus_inbuf + d_Lcl_MIA_SW1_ADRR/2; //[16sc[8+1ch][32en]
if (pCtrl->uc_mode < 6) {
uc_info = 0; //繧ｳ繝｡繝ｳ繝 INFO
//繝励Ο繝繧ｯ繝: 3D-LL(8s) [88+1dir][32en]
if ((ui_sp_sync & 0x01) == 0) { //1st/2
app03_MIA_88dir(pus_ALLCnt, //[INPUT] 蜈き繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ
pus_outbuf + d_Lcl_MIA_HK2B, //[OUTPUT]蜃ｺ蜉帙ヰ繝ヵ繧｡
FALSE); //[INPUT] FALSE:莉｣蜈･
if (pCtrl->uc_snap_ave) us_Mlen = d_Lcl_MIA_HK2B + 32*89; //繝繧ｿ髟ｷ SNAPSHOT縺ｯTLM騾∽ｿ｡
else us_Mlen = 0; // AVERAGE縺ｯ蜃ｦ逅縺ｿ
}
else { //2nd/2
if (pCtrl->uc_snap_ave) us_Mlen = 0; //繝繧ｿ髟ｷ SNAPSHOT縺ｯ蜃ｦ逅LM騾∽ｿ｡辟｡縺
else {
us_Mlen = d_Lcl_MIA_HK2B + 32*89; //繝繧ｿ髟ｷ AVERAGE縺ｯ蜉邂励＠縺ｦTLM騾∽ｿ｡
app03_MIA_88dir(pus_ALLCnt, //[INPUT] 蜈き繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ
pus_outbuf + d_Lcl_MIA_HK2B, //[OUTPUT]蜃ｺ蜉帙ヰ繝ヵ繧｡
TRUE); //[INPUT] TRUE:蜉邂
}
}
}
else {
//Option 2
//pDat->uc_info = 7; //繧ｳ繝｡繝ｳ繝 INFO
//pus_cnt0 = pus_outbuf + d_Lcl_MIA_HK2B;
//for (i = 0; i < 16; ++i) {
// memcpy(pus_cnt0 + 5*32*i, pus_inbuf + 6*32 + 17*32*i, 4*32*2); //荳ｭ螟ｮ4CH(6-9)
// memcpy(pus_cnt0 + (4 + 5*i)*32, pus_inbuf + 16*32 + 17*32*i, 32*2); //BGCH
//}
//pDat->us_Mlen = d_Lcl_MIA_HK2B + 16*5*32; //繝繧ｿ髟ｷ
//Option 1
uc_info = 7; //繧ｳ繝｡繝ｳ繝 INFO
//繝励Ο繝繧ｯ繝: 3D-L2(4s) [4sc][16+1ch][32en]
memcpy(pus_outbuf + d_Lcl_MIA_HK2B, pus_inbuf + 6*17*32, 4*17*32*2); //荳ｭ螟ｮ4sec x 16+1ch
us_Mlen = d_Lcl_MIA_HK2B + 4*17*32; //繝繧ｿ髟ｷ
}
}
else if (i_modeNo == 1) {
//M2 MG H
//繝励Ο繝繧ｯ繝: 3D-LL(us_pac, &pDat->us_3DL2[d_Lcl_MIA_HK2B], 1);8s) 32en x 8+1ch x 16sc
uc_info = 1; //繧ｳ繝｡繝ｳ繝 INFO
if ((ui_sp_sync & 0x01) == 0) {//1st/2
app03_MIA_3DM_M2(pus_inbuf, //[INPUT] 蜈き繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ
pus_outbuf + d_Lcl_MIA_HK2B, //[OUTPUT]蜃ｺ蜉帙ヰ繝ヵ繧｡
FALSE); //[INPUT] FALSE:莉｣蜈･
if (pCtrl->uc_snap_ave) us_Mlen = d_Lcl_MIA_HK2B + 32*9*16; //繝繧ｿ髟ｷ SNAPSHOT譎５LM騾∽ｿ｡
else us_Mlen = 0; // AVERAGE縺ｯ蜃ｦ逅縺ｿ
}
else { //2nd/2
if (pCtrl->uc_snap_ave) us_Mlen = 0; //繝繧ｿ髟ｷ SNAPSHOT縺ｯ蜃ｦ逅LM騾∽ｿ｡辟｡縺
else {
us_Mlen = d_Lcl_MIA_HK2B + 32*9*16; //繝繧ｿ髟ｷ AVERAGE縺ｯ蜉邂励＠縺ｦTLM騾∽ｿ｡
app03_MIA_3DM_M2(pus_inbuf, //[INPUT] 蜈き繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ
pus_outbuf + d_Lcl_MIA_HK2B, //[OUTPUT]蜃ｺ蜉帙ヰ繝ヵ繧｡
TRUE); //[INPUT] TRUE:蜉邂
}
}
}
else if (i_modeNo == 2) {
//M3 MG L
//繝励Ο繝繧ｯ繝: 3D-LL(8s) 32en x 88+1dir or
if (pCtrl->uc_mode >= 6 && pCtrl->uc_mode <= 0x0e) {
uc_info = 2; //繧ｳ繝｡繝ｳ繝 INFO
if ((ui_sp_sync & 0x01) == 0) { //1st/2
app03_MIA_88dir(pus_inbuf, //[INPUT] 蜈き繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ
pus_outbuf + d_Lcl_MIA_HK2B, //[OUTPUT]蜃ｺ蜉帙ヰ繝ヵ繧｡
FALSE); //[INPUT] FALSE:莉｣蜈･
if (pCtrl->uc_snap_ave) us_Mlen = d_Lcl_MIA_HK2B + 32*89; //繝繧ｿ髟ｷ SNAPSHOT譎５LM騾∽ｿ｡
else us_Mlen = 0; // AVERAGE縺ｯ蜃ｦ逅縺ｿ
}
else { //2nd/2
if (pCtrl->uc_snap_ave) us_Mlen = 0; //繝繧ｿ髟ｷ SNAPSHOT縺ｯ蜃ｦ逅LM騾∽ｿ｡辟｡縺
else {
us_Mlen = d_Lcl_MIA_HK2B + 32*89; //繝繧ｿ髟ｷ AVERAGE縺ｯ蜉邂励＠縺ｦTLM騾∽ｿ｡
app03_MIA_88dir(pus_inbuf, //[INPUT] 蜈き繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ
pus_outbuf + d_Lcl_MIA_HK2B, //[OUTPUT]蜃ｺ蜉帙ヰ繝ヵ繧｡
TRUE); //[INPUT] TRUE:蜉邂
}
}
}
//繝励Ο繝繧ｯ繝: 3D-LL(16s) 32en x 8+1ch x 16sc
// --> 3D-L2(4s) [88+1dir][16en]縺ｫ謾ｹ險 Oct. 2013
else {
uc_info = 3; //繧ｳ繝｡繝ｳ繝 INFO
app03_MIA_88dir(pus_inbuf, //[INPUT] 蜈き繧ｦ繝ｳ繝医ョ繝ｼ繧ｿ
pus_outbuf + d_Lcl_MIA_HK2B, //[OUTPUT]蜃ｺ蜉帙ヰ繝ヵ繧｡
FALSE); //[INPUT] FALSE:莉｣蜈･
//16en 蠕悟濠蛻ｊ蜃ｺ縺
pus_cnt0 = pus_outbuf + d_Lcl_MIA_HK2B;
pus_cnt1 = pus_outbuf + d_Lcl_MIA_HK2B;
for (i = 0; i < 89; ++i) {
pus_cnt1 += 16; //蜑榊濠縺瑚憶縺ｴ蜷医縺薙2蛻励ｒ蜈･繧梧崛縺医ｋ
for (k = 0; k < 16; ++k) *pus_cnt0++ = *pus_cnt1++;
}
us_Mlen = d_Lcl_MIA_HK2B + 16*89; //繝繧ｿ髟ｷ
}
}
else {
us_Mlen = d_Lcl_MIA_HK2B; //繝繧ｿ髟ｷ
uc_info = 5; //繧ｳ繝｡繝ｳ繝 INFO
//繝代こ繝ヨ縺ｮ蜈磯ｭ荳驛ｨ繧探LM
}
}
//###################### 繧ｨ繝ｳ繧ｸ繝九い繝ｪ繝ｳ繧ｰ繝｢繝ｼ繝 ########################
else if (pCtrl->uc_eng_sci == 1) {
//繝励Ο繝繧ｯ繝: SCI(28B):譌｢縺ｫ莉｣蜈･
pus_cnt0 = pus_outbuf + d_Lcl_MIA_HK2B;
//ASIC(12x4B)
memcpy(pus_cnt0, pDat->uc_ASICinf, d_Lcl_MIA_ASC_SIZE*d_Lcl_MIA_ASC_SPNN);
pus_cnt0 += d_Lcl_MIA_ASC_SIZE*d_Lcl_MIA_ASC_SPNN/2;
//HV(256x24B)/4spin
i = d_Lcl_MIA_HVB_SIZE*d_Lcl_MIA_HVB_SPNN/4;
memcpy(pus_cnt0, pDat->uc_HVinf + i_spinNo*i, i); //Spin No.縺ｫ縺ｦ蛻ｊ蜃ｺ縺鈴Κ蛻ｱｺ螳
uc_info = 4; //繧ｳ繝｡繝ｳ繝 INFO
us_Mlen = d_Lcl_MIA_HK2B + (d_Lcl_MIA_ASC_SIZE*d_Lcl_MIA_ASC_SPNN + i)/2; //繝繧ｿ髟ｷ
}
else {
us_Mlen = d_Lcl_MIA_HK2B; //繝繧ｿ髟ｷ
uc_info = 6; //繧ｳ繝｡繝ｳ繝 INFO
//繝代こ繝ヨ縺ｮ蜈磯ｭ荳驛ｨ繧探LM
}
if (us_Mlen == d_Lcl_MIA_HK2B + 32*9*16){ //pCtrl->uc_eng_sci == 0 && i_modeNo == 1
//8kB莉･荳翫↑縺ｮ縺ｧ2蛻牡
app03_MIA_tlmout(Gd_N_MIA, //[INPUT] sensor ID
pCtrl->uc_vet_cmp_ena, //[INPUT] 蝨ｧ邵ｮ繝輔Λ繧ｰ
d_Lcl_MIA_HK2B + 16*9*16, //[INPUT] data髟ｷ縺
uc_se_mode, //[INPUT] Comment2
uc_info, //[INPUT] Comment3
pus_outbuf, //[INPUT] 蝨ｧ邵ｮ蜑阪繝励Ο繝繧ｯ繝
pus_midbuf, //[MID] 蝨ｧ邵ｮ蠕後ヰ繝ヵ繧｡
pDat->ui_TIL, //[INPUT] TI
1); //[INPUT] 繝輔Λ繧ｰ縲0:L, 1: M, 4-9:H(DR-ID縺ｫ縺昴縺ｾ縺ｾ菴ｿ縺)
app03_MIA_tlmout(Gd_N_MIA, //[INPUT] sensor ID
pCtrl->uc_vet_cmp_ena, //[INPUT] 蝨ｧ邵ｮ繝輔Λ繧ｰ
16*9*16, //[INPUT] data髟ｷ縺
uc_se_mode, //[INPUT] Comment2
uc_info + 0x10, //[INPUT] Comment3
pus_outbuf + d_Lcl_MIA_HK2B + 16*9*16,//[INPUT] 蝨ｧ邵ｮ蜑阪繝励Ο繝繧ｯ繝
pus_midbuf, //[MID] 蝨ｧ邵ｮ蠕後ヰ繝ヵ繧｡
pDat->ui_TIL, //[INPUT] TI
1); //[INPUT] 繝輔Λ繧ｰ縲0:L, 1: M, 4-9:H(DR-ID縺ｫ縺昴縺ｾ縺ｾ菴ｿ縺)
}
else {
app03_MIA_tlmout(Gd_N_MIA, //[INPUT] sensor ID
pCtrl->uc_vet_cmp_ena, //[INPUT] 蝨ｧ邵ｮ繝輔Λ繧ｰ
us_Mlen, //[INPUT] data髟ｷ縺
uc_se_mode, //[INPUT] Comment2
uc_info, //[INPUT] Comment3
pus_outbuf, //[INPUT] 蝨ｧ邵ｮ蜑阪繝励Ο繝繧ｯ繝
pus_midbuf, //[MID] 蝨ｧ邵ｮ蠕後ヰ繝ヵ繧｡
pDat->ui_TIL, //[INPUT] TI
1); //[INPUT] 繝輔Λ繧ｰ縲0:L, 1: M, 4-9:H(DR-ID縺ｫ縺昴縺ｾ縺ｾ菴ｿ縺)
}
return TRUE;
}
char app03_MIA_tlmout( unsigned char uc_nodeId, //[INPUT] sensor ID
unsigned char uc_vetcmpena, //[INPUT] 蝨ｧ邵ｮ繝輔Λ繧ｰ
unsigned short us_len_total, //[INPUT] data髟ｷ縺
unsigned char uc_cm2_mod, //[INPUT] Comment2
unsigned char uc_cm3_inf, //[INPUT] Comment3
unsigned short *pus_inbuf, //[INPUT] 蝨ｧ邵ｮ蜑阪繝励Ο繝繧ｯ繝
unsigned short *pus_midbuf, //[MID] 蝨ｧ邵ｮ蠕後ヰ繝ヵ繧｡
unsigned int ui_TI, //[INPUT] TI
unsigned char uc_lmhflg) //[INPUT] 繝輔Λ繧ｰ縲0:L, 1: M, 4-9:H(DR-ID縺ｫ縺昴縺ｾ縺ｾ菴ｿ縺)
{
unsigned char uc_cmp; // rev by YK 121125
unsigned short us_outsize;
int ii;
unsigned char uc_drid, uc_commentSize, uc_cmnt[8];
unsigned char uc_appID;
unsigned short *pus_tlm;
int i_rice_format;
//繝繧ｿ髟ｷ縺0縺ｮ蝣ｴ蜷医菴輔ｂ菴懈縺励↑縺
if (us_len_total == 0) return FALSE;
uc_appID = (uc_lmhflg <= 1) ? 3 : 5;
uc_drid = (uc_lmhflg <= 1) ? uc_lmhflg+2 : uc_lmhflg;
//RICE_FMT_UINT
i_rice_format = (uc_cm2_mod & 0xc0) ? RICE_FMT_UINT8 : RICE_FMT_UINT16;
if (uc_vetcmpena || //蝨ｧ邵ｮ遖∵ｭ｢
(uc_nodeId == Gd_N_MIA && uc_lmhflg == 1 && uc_cm3_inf == 4)) { //MIA ENG M-product
//Guc_TLMm_cmp[Gd_N_MIA] = 0; // *** rev 121125 by YK *** app01縺ｧ螳溯｡
uc_cmp = 0; // non compress // *** rev 121125 by YK ***
us_outsize = us_len_total*2; //繝舌う繝磯聞蜈･蜉帙↑縺ｮ縺ｧ縲ゞS繝ｯ繝ｼ繝蛾聞繧2蛟阪↓縺吶ｋ
//memcpy(pus_midbuf, pus_inbuf, us_outsize);
pus_tlm = pus_inbuf;
}
else { //RICE蝨ｧ邵ｮ繧定｡後≧
//Guc_TLMm_cmp[Gd_N_MIA] = 3; // *** rev 121125 by YK *** app01縺ｧ螳溯｡
uc_cmp = 3; // 3:After-User-COMP // *** rev 121125 by YK ***
us_outsize = Rice_Compress(pus_inbuf, pus_midbuf, us_len_total*2, i_rice_format);
pus_tlm = pus_midbuf;
}
//繧ｳ繝｡繝ｳ繝
uc_cmnt[0] = d_Lcl_MIA_TLMID0;
if (uc_nodeId == Gd_N_MEA1) uc_cmnt[1] = d_Lcl_MEA1_TLMID1;
else if (uc_nodeId == Gd_N_MEA2) uc_cmnt[1] = d_Lcl_MEA2_TLMID1;
else if (uc_nodeId == Gd_N_MIA) uc_cmnt[1] = d_Lcl_MIA_TLMID1;
else if (uc_nodeId == Gd_N_MSA) uc_cmnt[1] = d_Lcl_MSA_TLMID1;
else return FALSE;
uc_cmnt[2] = uc_cm2_mod;
uc_cmnt[3] = uc_cm3_inf;
uc_cmnt[4] = us_len_total*2 >> 8 & 0xff; //蝨ｧ邵ｮ蜑阪ョ繝ｼ繧ｿ繧ｵ繧､繧ｺ, 2B縺ｮ繝ｯ繝ｼ繝蛾聞縺ｪ縺ｮ縺ｧ2蛟阪☆繧
uc_cmnt[5] = us_len_total*2 & 0xff;
uc_cmnt[6] = us_outsize >> 8 & 0xff; // 蝨ｧ邵ｮ蠕後ョ繝ｼ繧ｿ繧ｵ繧､繧ｺ
uc_cmnt[7] = us_outsize & 0xff;
uc_commentSize = 8;
ii = app_PutTlm( uc_appID, // [INPUT] APP-NUM
uc_nodeId, // [INPUT] Node-ID
0, // [INPUT] Data-ID
uc_nodeId, // [INPUT] Header-ID (for PID-ID, CAT-ID setting)
uc_drid, // [INPUT]**DR-ID (for CAT-ID) [0:HK 1:OS 2:L 3:M 4-9:H(0-5)]
//Guc_TLMm_cmp[Gd_N_MIA], // *** rev 121125 by YK ***
uc_cmp, // [INPUT] Comp mode [0:non 1:JPEG-rev 2:JPEG-nonrev 3:After-User-COMP
// 4: User defined pre-compression]
0xff, // [INPUT]**Packet ID <<<< USER-DEF: 0x00- 0xFF >>>>
ui_TI, // [INPUT]**Data TI <<<< USER-DEF: 0x00000000-0xFFFFFFFF >>>>
uc_cmnt, // [INPUT] Comment <<<< USER-DEF: <128B >>>>
uc_commentSize, // [INPUT] Comment - Size <<<< USER-DEF: <128B >>>>
(unsigned char*) pus_tlm,// [INPUT]**Data <<<< USER-DEF: <0x1E00 >>>>
(int)us_outsize); // [INPUT]**Data - Size ﾂ･ <<<< USER-DEF: <0x1E00 >>>>
return TRUE;
}
//
// Debug逕ｨ
//
/*
char app03_MIA_tlmout2( unsigned short *pus_inbuf, //[INPUT] 蝨ｧ邵ｮ蜑阪繝励Ο繝繧ｯ繝
unsigned short *pus_outbuf,//[MID] 蝨ｧ邵ｮ蠕後ヰ繝ヵ繧｡
unsigned char uc_lmhflg) //[INPUT] 繝輔Λ繧ｰ縲0:L, 1: M, 4-9:H(DR-ID縺ｫ縺昴縺ｾ縺ｾ菴ｿ縺)
{
unsigned char uc_cmp;
unsigned short us_length, us_outsize;
int ii;
unsigned char uc_drid, uc_pacId, uc_commentSize, uc_cmnt[8];
unsigned int ui_TI;
unsigned char *uc_hdr;
unsigned char uc_appID;
struct _s_MIA_Product *pDat; //繝励Ο繝繧ｯ繝
struct _s_MIA_CtrlParam *pCtrl; //蛻ｶ蠕｡逕ｨ縺ｮ繝輔Λ繧ｰ蜿翫繝代Λ繝｡繝ｼ繧ｿ
pDat = &Gst_MIA_dat;
pCtrl = &Gst_MIA_ctrl;
uc_appID = 3;
uc_drid = 2;
us_length = 32*25/2;
ui_TI = 0xee; //L mode
uc_pacId = 0xcc; //繧ｵ繧､繧ｨ繝ｳ繧ｹ繝繧ｿ繧ｫ繧ｦ繝ｳ繧ｿ繧偵ヱ繧ｱ繝ヨID縺ｨ縺励※菴ｿ縺
if (pCtrl->uc_vet_cmp_ena) {//蝨ｧ邵ｮ遖∵ｭ｢
uc_cmp = 0; // non compress
us_outsize = us_length*2;//繝舌う繝磯聞蜈･蜉帙↑縺ｮ縺ｧ縲ゞS繝ｯ繝ｼ繝蛾聞繧2蛟阪↓縺吶ｋ
memcpy(pus_outbuf, pus_inbuf, us_outsize);
}
else { //RICE蝨ｧ邵ｮ繧定｡後≧
uc_cmp = 3; // 3:After-User-COMP
us_outsize = Rice_Compress(pus_inbuf, pus_outbuf, us_length*2, RICE_FMT_UINT16);
}
//繧ｳ繝｡繝ｳ繝
uc_cmnt[0] = d_Lcl_MIA_TLMID0;
uc_cmnt[1] = d_Lcl_MIA_TLMID1;
uc_cmnt[2] = pCtrl->uc_snap_ave | (pCtrl->uc_eng_sci << 1 & 0x02)
| (pCtrl->uc_mode << 2 & 0xfc);
uc_cmnt[3] = 0;
uc_cmnt[4] = us_length*2 >> 8 & 0xff; //蝨ｧ邵ｮ蜑阪ョ繝ｼ繧ｿ繧ｵ繧､繧ｺ, 2B縺ｮ繝ｯ繝ｼ繝蛾聞縺ｪ縺ｮ縺ｧ2蛟阪☆繧
uc_cmnt[5] = us_length*2 & 0xff;
uc_cmnt[6] = us_outsize >> 8 & 0xff; // 蝨ｧ邵ｮ蠕後ョ繝ｼ繧ｿ繧ｵ繧､繧ｺ
uc_cmnt[7] = us_outsize & 0xff;
uc_commentSize = 8;
ii = app_PutTlm( uc_appID, // [INPUT] APP-NUM
Gd_N_MIA, // [INPUT] Node-ID
0, // [INPUT] Data-ID
Gd_N_MIA, // [INPUT] Header-ID (for PID-ID, CAT-ID setting)
uc_drid, // [INPUT]**DR-ID (for CAT-ID) [0:HK 1:OS 2:L 3:M 4-9:H(0-5)]
uc_cmp, // [INPUT] Comp mode [0:non 1:JPEG-rev 2:JPEG-nonrev 3:After-User-COMP
// 4: User defined pre-compression]
uc_pacId, // [INPUT]**Packet ID <<<< USER-DEF: 0x00- 0xFF >>>>
ui_TI, // [INPUT]**Data TI <<<< USER-DEF: 0x00000000-0xFFFFFFFF >>>>
uc_cmnt, // [INPUT] Comment <<<< USER-DEF: <128B >>>>
uc_commentSize, // [INPUT] Comment - Size <<<< USER-DEF: <128B >>>>
(unsigned char*) pus_outbuf, // [INPUT]**Data <<<< USER-DEF: <0x1E00 >>>>
(int)us_outsize); // [INPUT]**Data - Size <<<< USER-DEF: <0x1E00 >>>>
return TRUE;
}
*/
////[16sc][8+1ch][32en] --> [88+1dir][32en]
// 3D-L2-M1(8s) [88+1dir][32en] M-mode
// 3D-L2-M3(8s) [88+1dir][32en] M-mode
// 3D-L2-M1(4s) [88+1dir][32en] H-mode 蜷御ｸ縺ｮ繝舌ャ繝輔ぃ繧剃ｽｿ縺
//uc_f: TRUE 蜉邂 FALSE 莉｣蜈･
char app03_MIA_88dir(unsigned short *pus_inbuf, unsigned short *pus_outbuf, unsigned char uc_f)
{
int j, k, i_cell;
unsigned short *pus_cnt0, *pus_cnt1, *pus_cnt2;
i_cell = 32;
if (uc_f) {
//Center BG 0
for (j = 0; j < 16; ++j) {
pus_cnt0 = pus_outbuf;
pus_cnt1 = pus_inbuf + (8 + 9*j)*i_cell;
for (k = 0; k < 32; ++k) *pus_cnt0++ += *pus_cnt1++;
}
//1-89
for (j = 0; j < 4; ++j) {
pus_cnt0 = pus_outbuf + ( 1 + 22*j)*i_cell;
pus_cnt1 = pus_inbuf + ( 1 + 36*j)*i_cell;
pus_cnt2 = pus_inbuf + (10 + 36*j)*i_cell;
for (k = 0; k < i_cell; ++k) *pus_cnt0++ += *pus_cnt1++ + *pus_cnt2++; //cell = 1
for (k = 0; k < i_cell*4; ++k) *pus_cnt0++ += *pus_cnt1++; //cell = 2-5
pus_cnt2 = pus_inbuf + (15 + 36*j)*i_cell;
for (k = 0; k < i_cell; ++k) *pus_cnt0++ += *pus_cnt1++ + *pus_cnt2++; //cell = 6
pus_cnt1 = pus_inbuf + (11 + 36*j)*i_cell;
for (k = 0; k < i_cell*4; ++k) *pus_cnt0++ += *pus_cnt1++; //cell = 7-10
pus_cnt1 = pus_inbuf + (18 + 36*j)*i_cell;
pus_cnt2 = pus_inbuf + (27 + 36*j)*i_cell;
for (k = 0; k < i_cell*2; ++k) *pus_cnt0++ += *pus_cnt1++ + *pus_cnt2++; //cell = 11,12
for (k = 0; k < i_cell*4; ++k) *pus_cnt0++ += *pus_cnt1++; //cell = 13-16
pus_cnt2 = pus_inbuf + (33 + 36*j)*i_cell;
for (k = 0; k < i_cell*2; ++k) *pus_cnt0++ += *pus_cnt1++ + *pus_cnt2++; //cell = 17,18
pus_cnt1 = pus_inbuf + (29 + 36*j)*i_cell;
for (k = 0; k < i_cell*4; ++k) *pus_cnt0++ += *pus_cnt1++; //cell = 19-22
}
}
else {
//Center BG 0
pus_cnt0 = pus_outbuf;
pus_cnt1 = pus_inbuf + 8*i_cell;
for (k = 0; k < 32; ++k) *pus_cnt0++ = *pus_cnt1++;
for (j = 1; j < 16; ++j) {
pus_cnt0 = pus_outbuf;
pus_cnt1 = pus_inbuf + (8 + 9*j)*i_cell;
for (k = 0; k < 32; ++k) *pus_cnt0++ += *pus_cnt1++;
}
//1-89
for (j = 0; j < 4; ++j) {
pus_cnt0 = pus_outbuf + ( 1 + 22*j)*i_cell;
pus_cnt1 = pus_inbuf + ( 1 + 36*j)*i_cell;
pus_cnt2 = pus_inbuf + (10 + 36*j)*i_cell;
for (k = 0; k < i_cell; ++k) *pus_cnt0++ = *pus_cnt1++ + *pus_cnt2++; //cell = 1
for (k = 0; k < i_cell*4; ++k) *pus_cnt0++ = *pus_cnt1++; //cell = 2-5
pus_cnt2 = pus_inbuf + (15 + 36*j)*i_cell;
for (k = 0; k < i_cell; ++k) *pus_cnt0++ = *pus_cnt1++ + *pus_cnt2++; //cell = 6
pus_cnt1 = pus_inbuf + (11 + 36*j)*i_cell;
for (k = 0; k < i_cell*4; ++k) *pus_cnt0++ = *pus_cnt1++; //cell = 7-10
pus_cnt1 = pus_inbuf + (18 + 36*j)*i_cell;
pus_cnt2 = pus_inbuf + (27 + 36*j)*i_cell;
for (k = 0; k < i_cell*2; ++k) *pus_cnt0++ = *pus_cnt1++ + *pus_cnt2++; //cell = 11,12
for (k = 0; k < i_cell*4; ++k) *pus_cnt0++ = *pus_cnt1++; //cell = 13-16
pus_cnt2 = pus_inbuf + (33 + 36*j)*i_cell;
for (k = 0; k < i_cell*2; ++k) *pus_cnt0++ = *pus_cnt1++ + *pus_cnt2++; //cell = 17,18
pus_cnt1 = pus_inbuf + (29 + 36*j)*i_cell;
for (k = 0; k < i_cell*4; ++k) *pus_cnt0++ = *pus_cnt1++; //cell = 19-22
}
}
return TRUE;
}
//M2 data [32sc][32+2ch][32en]--Packetread--> [32sc][16+1ch][32en] -->
// 3D-L2-M2(8s) [16sc][8+1ch][32en] M-mode
//uc_f: TRUE 蜉邂
// FALSE 莉｣蜈･
char app03_MIA_3DM_M2(unsigned short *pus_inbuf, unsigned short *pus_outbuf, unsigned char uc_f)
{
int i, j, k;
unsigned short *pus_cnt0, *pus_cnt1, *pus_cnt2, *pus_cnt3, *pus_cnt4;
// for (j = 0; j < 16; ++j)
// for (i = 0; i < 17; ++i) //i = 16 center back ground
// for (k = 0; k < 32; ++k)
// *(pus_outbuf + k + i/2*32 + j/2*288) += *(pus_inbuf + k + i*32 + j*544);
if (uc_f) {
for (j = 0; j < 16; ++j) {
for (i = 0; i < 8; ++i) {
pus_cnt0 = pus_outbuf + i*32 + j*288;
pus_cnt1 = pus_inbuf + 2*i*32 + 2*j*544;
pus_cnt2 = pus_inbuf + (2*i+1)*32 + 2*j*544;
pus_cnt3 = pus_inbuf + 2*i*32 + (2*j+1)*544;
pus_cnt4 = pus_inbuf + (2*i+1)*32 + (2*j+1)*544;
for (k = 0; k < 32; ++k)
*pus_cnt0++ += *pus_cnt1++ + *pus_cnt2++ + *pus_cnt3++ + *pus_cnt4++;
}
i = 8;
pus_cnt0 = pus_outbuf + i*32 + j*288;
pus_cnt1 = pus_inbuf + 2*i*32 + 2*j*544;
pus_cnt2 = pus_inbuf + 2*i*32 + (2*j+1)*544;
for (k = 0; k < 32; ++k) *pus_cnt0++ += *pus_cnt1++ + *pus_cnt2++;
}
}
else {
for (j = 0; j < 16; ++j) {
for (i = 0; i < 8; ++i) {
pus_cnt0 = pus_outbuf + i*32 + j*288;
pus_cnt1 = pus_inbuf + 2*i*32 + 2*j*544;
pus_cnt2 = pus_inbuf + (2*i+1)*32 + 2*j*544;
pus_cnt3 = pus_inbuf + 2*i*32 + (2*j+1)*544;
pus_cnt4 = pus_inbuf + (2*i+1)*32 + (2*j+1)*544;
for (k = 0; k < 32; ++k)
*pus_cnt0++ = *pus_cnt1++ + *pus_cnt2++ + *pus_cnt3++ + *pus_cnt4++;
}
i = 8;
pus_cnt0 = pus_outbuf + i*32 + j*288;
pus_cnt1 = pus_inbuf + 2*i*32 + 2*j*544;
pus_cnt2 = pus_inbuf + 2*i*32 + (2*j+1)*544;
for (k = 0; k < 32; ++k) *pus_cnt0++ = *pus_cnt1++ + *pus_cnt2++;
}
}
return TRUE;
}
//
// 32bit UINT linear -> 16bit UCHAR x 2 log
// 32bit -> 8bit UCHAR app04_MPPE-ENA.c
/*
char app03_MIA_UINTtoUSHORT(unsigned int *pinbuf, unsigned short *poutbuf, unsigned int len)
{
int i;
unsigned int ui;
for(i = 0; i < len; i++){
//ui = *pinbuf++ - offset;
ui = *pinbuf++;
if ( !(ui & 0xffffc000) ) *poutbuf++ = (ui & 0x3fff);
else if( !(ui & 0xffff8000) ) *poutbuf++ = ( 0x4000 | ((ui >> 2) & 0x0fff) );
else if( !(ui & 0xffff0000) ) *poutbuf++ = ( 0x5000 | ((ui >> 3) & 0x0fff) );
else if( !(ui & 0xfffe0000) ) *poutbuf++ = ( 0x6000 | ((ui >> 4) & 0x0fff) );
else if( !(ui & 0xfffc0000) ) *poutbuf++ = ( 0x7000 | ((ui >> 5) & 0x0fff) );
else if( !(ui & 0xfff80000) ) *poutbuf++ = ( 0x8000 | ((ui >> 6) & 0x0fff) );
else if( !(ui & 0xfff00000) ) *poutbuf++ = ( 0x9000 | ((ui >> 7) & 0x0fff) );
else if( !(ui & 0xffe00000) ) *poutbuf++ = ( 0xa000 | ((ui >> 9) & 0x07ff) );
else if( !(ui & 0xffc00000) ) *poutbuf++ = ( 0xa800 | ((ui >> 10) & 0x07ff) );
else if( !(ui & 0xff800000) ) *poutbuf++ = ( 0xb000 | ((ui >> 11) & 0x07ff) );
else if( !(ui & 0xff000000) ) *poutbuf++ = ( 0xb800 | ((ui >> 12) & 0x07ff) );
else if( !(ui & 0xfe000000) ) *poutbuf++ = ( 0xc000 | ((ui >> 13) & 0x07ff) );
else if( !(ui & 0xfc000000) ) *poutbuf++ = ( 0xc800 | ((ui >> 14) & 0x07ff) );
else if( !(ui & 0xf8000000) ) *poutbuf++ = ( 0xd000 | ((ui >> 15) & 0x07ff) );
else if( !(ui & 0xf0000000) ) *poutbuf++ = ( 0xd800 | ((ui >> 16) & 0x07ff) );
else if( !(ui & 0xe0000000) ) *poutbuf++ = ( 0xe000 | ((ui >> 17) & 0x07ff) );
else if( !(ui & 0xc0000000) ) *poutbuf++ = ( 0xe800 | ((ui >> 18) & 0x07ff) );
else if( !(ui & 0x80000000) ) *poutbuf++ = ( 0xf000 | ((ui >> 19) & 0x07ff) );
else *poutbuf++ = ( 0xf800 | ((ui >> 20) & 0x07ff) );
}
return TRUE;
}
*/
//
//
//
char app03_MIA_DBLtoUSHORT(double *pf_inbuf, unsigned short *pus_outbuf, unsigned int len)
{
int i;
//蜈ｱ逕ｨ菴
union {
double d;//1(sign) + 11(exponent) + 52(fraction)
unsigned char uc[8];
} un_dat;
for(i = 0; i < len; i++){
un_dat.d = *pf_inbuf++;
//1(sign) + 5(exponent) + 10(fraction)
//USHORT蛛ｴ縺ｯ2B縺ｧ蟇ｾ蠢懊☆繧九◆繧√√お繝ｳ繝ぅ繧｢繝ｳ縺ｫ閾ｪ蜍慕噪縺ｫ蠕薙≧縲
//DBL蛛ｴ縺ｯ1B縺壹▽蜃ｦ逅ｒ縺吶ｋ縺溘ａ縲√お繝ｳ繝ぅ繧｢繝ｳ繧呈э隴倥＠縺溷逅ｒ縺吶ｋ縲
if (un_dat.d > 65504) *pus_outbuf++ = 0x7c00; //+辟｡髯仙､ｧ
else if (un_dat.d < -65504) *pus_outbuf++ = 0xfc00; //-辟｡髯仙､ｧ
else if (un_dat.d > -6.10352e-5 && un_dat.d < 6.10352e-5) *pus_outbuf++ = 0x0000; //0
else {
//DPU荳翫〒縺ｯBIG ENDIAN縺御ｽｿ逕ｨ縺輔ｌ繧
#ifdef _RUN_ON_WINDOWS_ //LITTLE ENDIAN
*pus_outbuf++ = ((un_dat.uc[7] & 0xc0) << 8) | (un_dat.uc[6] << 6) //豁｣隕丞喧謨ｰ
| ((un_dat.uc[5] >> 2) & 0x3f);
#else //BIG ENDIAN
*pus_outbuf++ = ((un_dat.uc[0] & 0xc0) << 8) | (un_dat.uc[1] << 6) //豁｣隕丞喧謨ｰ
| ((un_dat.uc[2] >> 2) & 0x3f);
#endif
}
}
return TRUE;
}