diff --git a/openair1/PHY/LTE_TRANSPORT/dci_tools.c b/openair1/PHY/LTE_TRANSPORT/dci_tools.c index 0da47dbdfff85c86fa9ebc056f55a8c040e626c4..d044ea45d8eccbc4eb9130fe7605ccc0bd8a8292 100755 --- a/openair1/PHY/LTE_TRANSPORT/dci_tools.c +++ b/openair1/PHY/LTE_TRANSPORT/dci_tools.c @@ -44,6 +44,7 @@ #include "PHY/vars.h" #endif #include "assertions.h" +//#define DEBUG_HARQ //#define DEBUG_DCI @@ -1525,7 +1526,9 @@ int generate_eNB_dlsch_params_from_dci(int frame, dlsch1_harq->status = ACTIVE; dlsch0_harq->codeword=0; dlsch1_harq->codeword=1; +#ifdef DEBUG_HARQ printf("\n ENB: BOTH ACTIVE\n"); +#endif } else if (TB0_active && TB1_active && tbswap==1) { dlsch0=dlsch[0]; @@ -1564,7 +1567,9 @@ int generate_eNB_dlsch_params_from_dci(int frame, dlsch1_harq->codeword = 0; dlsch0=NULL; dlsch0_harq = NULL; +#ifdef DEBUG_HARQ printf("\n ENB: TB0 is deactivated, retransmit TB1 transmit in TM6\n"); +#endif } if (dlsch0 != NULL){ @@ -2800,8 +2805,15 @@ int generate_eNB_dlsch_params_from_dci(int frame, #endif // compute DL power control parameters + if (dlsch0 != NULL){ computeRhoA_eNB(pdsch_config_dedicated, dlsch[0],dlsch0_harq->dl_power_off, frame_parms->nb_antennas_tx_eNB); computeRhoB_eNB(pdsch_config_dedicated,&(frame_parms->pdsch_config_common),frame_parms->nb_antennas_tx_eNB,dlsch[0],dlsch0_harq->dl_power_off); +} + if (dlsch1 != NULL){ + computeRhoA_eNB(pdsch_config_dedicated, dlsch[1],dlsch1_harq->dl_power_off, frame_parms->nb_antennas_tx_eNB); + computeRhoB_eNB(pdsch_config_dedicated,&(frame_parms->pdsch_config_common),frame_parms->nb_antennas_tx_eNB,dlsch[1],dlsch1_harq->dl_power_off); + } + return(0); } @@ -4879,6 +4891,9 @@ int generate_ue_dlsch_params_from_dci(int frame, if ((rv2 == 1) && (mcs2 == 0)) { TB1_active=0; } +#ifdef DEBUG_HARQ + printf("[DCI UE]: TB0 status %d , TB1 status %d\n", TB0_active, TB1_active); +#endif //printf("RV TB0 = %d\n", rv1); @@ -4898,7 +4913,9 @@ int generate_ue_dlsch_params_from_dci(int frame, dlsch1_harq->status = ACTIVE; dlsch0_harq->codeword=0; dlsch1_harq->codeword=1; - //printf("\n UE: BOTH ACTIVE\n"); +#ifdef DEBUG_HARQ + printf("[DCI UE]: BOTH ACTIVE\n"); +#endif } else if (TB0_active && TB1_active && tbswap==1) { dlsch0=dlsch[0]; @@ -4937,7 +4954,9 @@ int generate_ue_dlsch_params_from_dci(int frame, dlsch1_harq->codeword = 0; dlsch0=NULL; dlsch0_harq = NULL; - //printf("\n UE: TB0 is deactivated, retransmit TB1 transmit in TM6\n"); +#ifdef DEBUG_HARQ + printf("[DCI UE]: TB0 is deactivated, retransmit TB1 transmit in TM6\n"); +#endif } @@ -4990,7 +5009,9 @@ int generate_ue_dlsch_params_from_dci(int frame, dlsch1_harq->rb_alloc_odd[1]= dlsch1_harq->rb_alloc_even[1]; dlsch1_harq->rb_alloc_odd[2]= dlsch1_harq->rb_alloc_even[2]; dlsch1_harq->rb_alloc_odd[3]= dlsch1_harq->rb_alloc_even[3]; - dlsch1_harq->nb_rb = dlsch0_harq->nb_rb; + dlsch1_harq->nb_rb = conv_nprb(rah, + rballoc, + frame_parms->N_RB_DL); } @@ -5010,6 +5031,9 @@ int generate_ue_dlsch_params_from_dci(int frame, if (dlsch1_harq != NULL) dlsch1_harq->Nl = 1; +#ifdef DEBUG_HARQ + printf ("[DCI UE] tpmi = %d\n", tpmi); +#endif if ((dlsch0 != NULL) && (dlsch1 != NULL)){ //two CW active @@ -5112,7 +5136,10 @@ int generate_ue_dlsch_params_from_dci(int frame, break; } } - +#ifdef DEBUG_HARQ + printf("[DCI UE] harq1 MIMO mode = %d\n", dlsch1_harq->mimo_mode); +#endif + //printf(" UE DCI harq0 MIMO mode = %d\n", dlsch0_harq->mimo_mode); if ((frame_parms->mode1_flag == 1) && (dlsch0_harq != NULL)) dlsch0_harq->mimo_mode = SISO; @@ -5196,6 +5223,12 @@ int generate_ue_dlsch_params_from_dci(int frame, dlsch1->rnti = rnti; } +#ifdef DEBUG_HARQ + if (dlsch0 != NULL) + printf("[DCI UE] dlsch0_harq status = %d, dlsch1_harq status = %d\n", dlsch0_harq->status, dlsch1_harq->status); + else + printf("[DCI UE] dlsch1_harq status = %d\n", dlsch1_harq->status); +#endif break; @@ -5869,11 +5902,19 @@ int generate_ue_dlsch_params_from_dci(int frame, } #endif - dlsch[0]->active=1; + //dlsch[0]->active=1; // compute DL power control parameters - computeRhoA_UE(pdsch_config_dedicated, dlsch[0],dlsch0_harq->dl_power_off, frame_parms->nb_antennas_tx_eNB); - computeRhoB_UE(pdsch_config_dedicated,&(frame_parms->pdsch_config_common),frame_parms->nb_antennas_tx_eNB,dlsch[0],dlsch0_harq->dl_power_off); + if (dlsch0_harq != NULL){ + computeRhoA_UE(pdsch_config_dedicated, dlsch[0],dlsch0_harq->dl_power_off, frame_parms->nb_antennas_tx_eNB); + computeRhoB_UE(pdsch_config_dedicated,&(frame_parms->pdsch_config_common),frame_parms->nb_antennas_tx_eNB,dlsch[0],dlsch0_harq->dl_power_off); + } + + if (dlsch1_harq != NULL) { + computeRhoA_UE(pdsch_config_dedicated, dlsch[1],dlsch1_harq->dl_power_off, frame_parms->nb_antennas_tx_eNB); + computeRhoB_UE(pdsch_config_dedicated,&(frame_parms->pdsch_config_common),frame_parms->nb_antennas_tx_eNB,dlsch[1],dlsch1_harq->dl_power_off); + } + return(0); } diff --git a/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c b/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c old mode 100755 new mode 100644 index 59e988861b5bc2f4621d3969480894ab3312d23c..0b16c1953fbb6a2eb698d5a1090b6377a197689c --- a/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c +++ b/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c @@ -37,8 +37,7 @@ * \note * \warning */ - -#include "PHY/defs.h" +//#include "PHY/defs.h" #include "PHY/extern.h" #include "defs.h" #include "extern.h" @@ -51,6 +50,8 @@ #define NOCYGWIN_STATIC #endif +//#define DEBUG_HARQ + //#undef LOG_D //#define LOG_D LOG_I @@ -68,9 +69,9 @@ uint8_t interf_unaw_shift1=0; uint8_t interf_unaw_shift=0; //inferference-free case unsigned char interf_unaw_shift_tm4_mcs[29]={5, 3, 4, 3, 3, 2, 1, 1, 2, 0, 1, 1, 1, 1, 0, 0, - 1, 1, 1, 1, 0, 2, 1, 0, 1, 0, 1, 0, 0} ; + 1, 1, 1, 1, 0, 2, 1, 0, 1, 0, 1, 0, 0} ; unsigned char interf_unaw_shift_tm1_mcs[29]={5, 5, 4, 3, 3, 3, 2, 2, 4, 4, 2, 3, 3, 3, 1, 1, - 0, 1, 1, 2, 5, 4, 4, 6, 5, 1, 0, 5, 6} ; // mcs 21, 26, 28 seem to be errorneous + 0, 1, 1, 2, 5, 4, 4, 6, 5, 1, 0, 5, 6} ; // mcs 21, 26, 28 seem to be errorneous /* //original values from sebastion + same hand tuning @@ -139,12 +140,30 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, break; case PDSCH: + lte_ue_pdsch_vars = &phy_vars_ue->lte_ue_pdsch_vars[eNB_id]; dlsch_ue = phy_vars_ue->dlsch_ue[eNB_id]; - codeword_TB0 = dlsch_ue[0]->harq_processes[harq_pid]->codeword; - codeword_TB1 = dlsch_ue[1]->harq_processes[harq_pid]->codeword; - dlsch0_harq = dlsch_ue[codeword_TB0]->harq_processes[harq_pid]; - dlsch1_harq = dlsch_ue[codeword_TB1]->harq_processes[harq_pid]; + if ((dlsch_ue[0]->harq_processes[harq_pid]->status == ACTIVE) && + (dlsch_ue[1]->harq_processes[harq_pid]->status == ACTIVE)){ + codeword_TB0 = dlsch_ue[0]->harq_processes[harq_pid]->codeword; + codeword_TB1 = dlsch_ue[1]->harq_processes[harq_pid]->codeword; + dlsch0_harq = dlsch_ue[codeword_TB0]->harq_processes[harq_pid]; + dlsch1_harq = dlsch_ue[codeword_TB1]->harq_processes[harq_pid]; + } + else if ((dlsch_ue[0]->harq_processes[harq_pid]->status == ACTIVE) && + (dlsch_ue[1]->harq_processes[harq_pid]->status != ACTIVE) ) { + codeword_TB0 = dlsch_ue[0]->harq_processes[harq_pid]->codeword; + dlsch0_harq = dlsch_ue[0]->harq_processes[harq_pid]; + dlsch1_harq = NULL; + codeword_TB1 = -1; + } + else if ((dlsch_ue[0]->harq_processes[harq_pid]->status != ACTIVE) && + (dlsch_ue[1]->harq_processes[harq_pid]->status == ACTIVE) ){ + codeword_TB1 = dlsch_ue[1]->harq_processes[harq_pid]->codeword; + dlsch0_harq = dlsch_ue[1]->harq_processes[harq_pid]; + dlsch1_harq = NULL; + codeword_TB0 = -1; + } break; default: @@ -152,6 +171,10 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, return(-1); break; } +#ifdef DEBUG_HARQ + printf("[DEMOD] MIMO mode = %d\n", dlsch0_harq->mimo_mode); + printf("[DEMOD] cw for TB0 = %d, cw for TB1 = %d\n", codeword_TB0, codeword_TB1); +#endif DevAssert(dlsch0_harq); round = dlsch0_harq->round; @@ -216,11 +239,11 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, subframe, phy_vars_ue->high_speed_flag, frame_parms, - dlsch0_harq->mimo_mode); + dlsch0_harq->mimo_mode); //#ifdef DEBUG_DLSCH_MOD /* printf("dlsch: using pmi %lx, rb_alloc %x, pmi_ext ",pmi2hex_2Ar1(dlsch0_harq->pmi_alloc),*rballoc); for (rb=0;rb<nb_rb;rb++) - printf("%d",lte_ue_pdsch_vars[eNB_id]->pmi_ext[rb]); + printf("%d",lte_ue_pdsch_vars[eNB_id]->pmi_ext[rb]); printf("\n");*/ //#endif @@ -237,7 +260,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, subframe, phy_vars_ue->high_speed_flag, frame_parms, - dlsch0_harq->mimo_mode); + dlsch0_harq->mimo_mode); else nb_rb = dlsch_extract_rbs_dual(lte_ue_common_vars->rxdataF, lte_ue_common_vars->dl_ch_estimates[eNB_id], @@ -250,7 +273,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, subframe, phy_vars_ue->high_speed_flag, frame_parms, - dlsch0_harq->mimo_mode); + dlsch0_harq->mimo_mode); } } // if n_tx>1 else { @@ -311,14 +334,15 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, if (dlsch0_harq->mimo_mode<LARGE_CDD) {// SISO or ALAMOUTI + dlsch_scale_channel(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, - frame_parms, - dlsch_ue, - symbol, - nb_rb); + frame_parms, + dlsch_ue, + symbol, + nb_rb); if (first_symbol_flag==1) { - dlsch_channel_level(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, + dlsch_channel_level(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, frame_parms, avg, symbol, @@ -339,7 +363,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, } - dlsch_channel_compensation(lte_ue_pdsch_vars[eNB_id]->rxdataF_ext, + dlsch_channel_compensation(lte_ue_pdsch_vars[eNB_id]->rxdataF_ext, lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0, lte_ue_pdsch_vars[eNB_id]->dl_ch_magb0, @@ -359,7 +383,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, if ((rx_type==rx_IC_single_stream) && (eNB_id_i<phy_vars_ue->n_connected_eNB)) { - dlsch_channel_compensation(lte_ue_pdsch_vars[eNB_id_i]->rxdataF_ext, + dlsch_channel_compensation(lte_ue_pdsch_vars[eNB_id_i]->rxdataF_ext, lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext, lte_ue_pdsch_vars[eNB_id_i]->dl_ch_mag0, lte_ue_pdsch_vars[eNB_id_i]->dl_ch_magb0, @@ -399,23 +423,23 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, if (frame_parms->nb_antennas_tx_eNB == 2) { - // scaling interfering channel (following for TM56) - dlsch_scale_channel(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, - frame_parms, - dlsch_ue, - symbol, - nb_rb); + // scaling interfering channel (following for TM56) + dlsch_scale_channel(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, + frame_parms, + dlsch_ue, + symbol, + nb_rb); if (first_symbol_flag==1) { // effective channel of desired user is always stronger than interfering eff. channel dlsch_channel_level_TM34(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, frame_parms, - lte_ue_pdsch_vars[eNB_id]->pmi_ext, + lte_ue_pdsch_vars[eNB_id]->pmi_ext, avg_0, - avg_1, - symbol, - nb_rb, + avg_1, + symbol, + nb_rb, dlsch0_harq->mimo_mode); @@ -423,27 +447,27 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, // write_output("dlsch0_r0_aver_chan_1.m","dl_aver_ch1_r0_0",&avg_1[0],1,1,2); - if (rx_type>rx_standard) { - // Shifts are needed to avoid tails in SNR/BLER curves. - // LUT will be introduced with mcs-dependent shift - avg_0[0] = (log2_approx(avg_0[0])/2) -13 + interf_unaw_shift; - avg_1[0] = (log2_approx(avg_1[0])/2) -13 + interf_unaw_shift; - lte_ue_pdsch_vars[eNB_id]->log2_maxh0 = cmax(avg_0[0],0); - lte_ue_pdsch_vars[eNB_id]->log2_maxh1 = cmax(avg_1[0],0); - - //printf("TM4 I-A log2_maxh0 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh0); - //printf("TM4 I-A log2_maxh1 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh1); - - } - else { - // Shifts are needed to avoid tails in SNR/BLER curves. - // LUT will be introduced with mcs-dependent shift - avg_0[0] = (log2_approx(avg_0[0])/2) - 13 + interf_unaw_shift; - avg_1[0] = (log2_approx(avg_1[0])/2) - 13 + interf_unaw_shift; - lte_ue_pdsch_vars[eNB_id]->log2_maxh0 = cmax(avg_0[0],0); - lte_ue_pdsch_vars[eNB_id]->log2_maxh1 = cmax(avg_1[0],0); - //printf("TM4 I-UA log2_maxh0 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh0); - //printf("TM4 I-UA log2_maxh1 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh1); + if (rx_type>rx_standard) { + // Shifts are needed to avoid tails in SNR/BLER curves. + // LUT will be introduced with mcs-dependent shift + avg_0[0] = (log2_approx(avg_0[0])/2) -13 + interf_unaw_shift; + avg_1[0] = (log2_approx(avg_1[0])/2) -13 + interf_unaw_shift; + lte_ue_pdsch_vars[eNB_id]->log2_maxh0 = cmax(avg_0[0],0); + lte_ue_pdsch_vars[eNB_id]->log2_maxh1 = cmax(avg_1[0],0); + + //printf("TM4 I-A log2_maxh0 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh0); + //printf("TM4 I-A log2_maxh1 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh1); + + } + else { + // Shifts are needed to avoid tails in SNR/BLER curves. + // LUT will be introduced with mcs-dependent shift + avg_0[0] = (log2_approx(avg_0[0])/2) - 13 + interf_unaw_shift; + avg_1[0] = (log2_approx(avg_1[0])/2) - 13 + interf_unaw_shift; + lte_ue_pdsch_vars[eNB_id]->log2_maxh0 = cmax(avg_0[0],0); + lte_ue_pdsch_vars[eNB_id]->log2_maxh1 = cmax(avg_1[0],0); + //printf("TM4 I-UA log2_maxh0 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh0); + //printf("TM4 I-UA log2_maxh1 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh1); } } @@ -459,7 +483,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, dlsch0_harq->mimo_mode, nb_rb, lte_ue_pdsch_vars[eNB_id]->log2_maxh0, - lte_ue_pdsch_vars[eNB_id]->log2_maxh1); + lte_ue_pdsch_vars[eNB_id]->log2_maxh1); /* if (symbol == 5) { @@ -469,11 +493,11 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, write_output("rxF_comp_d11.m","rxF_c_d11",<e_ue_pdsch_vars[eNB_id]->rxdataF_comp1[harq_pid][round][1][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be QAM - } */ + } */ // compute correlation between signal and interference channels (rho12 and rho21) - dlsch_dual_stream_correlation(frame_parms, // this is doing h11'*h12 and h21'*h22 + dlsch_dual_stream_correlation(frame_parms, // this is doing h11'*h12 and h21'*h22 symbol, nb_rb, lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, @@ -481,17 +505,17 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext, lte_ue_pdsch_vars[eNB_id]->log2_maxh0); - //printf("rho stream1 =%d\n", <e_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round] ); + //printf("rho stream1 =%d\n", <e_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round] ); //to be optimized (just take complex conjugate) dlsch_dual_stream_correlation(frame_parms, // this is doing h12'*h11 and h22'*h21 symbol, nb_rb, - &(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext[2]), + &(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext[2]), lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, - lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round], - lte_ue_pdsch_vars[eNB_id]->log2_maxh1); + lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round], + lte_ue_pdsch_vars[eNB_id]->log2_maxh1); // printf("rho stream2 =%d\n",<e_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext ); //printf("TM3 log2_maxh : %d\n",lte_ue_pdsch_vars[eNB_id]->log2_maxh); @@ -503,7 +527,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, write_output("rho2_1.m","rho2_1",<e_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext[1][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be QAM - } */ + } */ } else { @@ -534,11 +558,11 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, // effective channel of desired user is always stronger than interfering eff. channel dlsch_channel_level_TM56(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, - frame_parms, - lte_ue_pdsch_vars[eNB_id]->pmi_ext, - avg, - symbol, - nb_rb); + frame_parms, + lte_ue_pdsch_vars[eNB_id]->pmi_ext, + avg, + symbol, + nb_rb); // LOG_D(PHY,"llr_offset = %d\n",offset_mumimo_llr_drange[dlsch0_harq->mcs][(i_mod>>1)-1]); avg[0] = log2_approx(avg[0]) - 13 + offset_mumimo_llr_drange[dlsch0_harq->mcs][(i_mod>>1)-1]; @@ -623,13 +647,14 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, else if (dlsch0_harq->dl_power_off==1) { dlsch_scale_channel(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, - frame_parms, - dlsch_ue, - symbol, - nb_rb); + frame_parms, + dlsch_ue, + symbol, + nb_rb); if (first_symbol_flag==1) { - dlsch_channel_level(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, + + dlsch_channel_level(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, frame_parms, avg, symbol, @@ -638,19 +663,19 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, LOG_D(PHY,"[DLSCH] avg[0] %d\n",avg[0]); #endif - avgs = 0; + avgs = 0; - for (aatx=0;aatx<frame_parms->nb_antennas_tx_eNB;aatx++) - for (aarx=0;aarx<frame_parms->nb_antennas_rx;aarx++) - avgs = cmax(avgs,avg[(aatx<<1)+aarx]); - // avgs = cmax(avgs,avg[(aarx<<1)+aatx]); + for (aatx=0;aatx<frame_parms->nb_antennas_tx_eNB;aatx++) + for (aarx=0;aarx<frame_parms->nb_antennas_rx;aarx++) + avgs = cmax(avgs,avg[(aatx<<1)+aarx]); + // avgs = cmax(avgs,avg[(aarx<<1)+aatx]); - lte_ue_pdsch_vars[eNB_id]->log2_maxh = (log2_approx(avgs)/2) + interf_unaw_shift_tm1_mcs[dlsch0_harq->mcs]; + lte_ue_pdsch_vars[eNB_id]->log2_maxh = (log2_approx(avgs)/2) + 1; + lte_ue_pdsch_vars[eNB_id]->log2_maxh++; } - dlsch_channel_compensation_TM56(lte_ue_pdsch_vars[eNB_id]->rxdataF_ext, lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0, @@ -676,20 +701,20 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, (dlsch0_harq->mimo_mode <=DUALSTREAM_PUSCH_PRECODING))){ // TM3 or TM4 if (frame_parms->nb_antennas_tx_eNB == 2) { - dlsch_detection_mrc_TM34(frame_parms, + dlsch_detection_mrc_TM34(frame_parms, lte_ue_pdsch_vars[eNB_id], - harq_pid, + harq_pid, dlsch0_harq->round, - symbol, - nb_rb, - 1); + symbol, + nb_rb, + 1); /* if (symbol == 5) { write_output("rho0_mrc.m","rho0_0",<e_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round][0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);// should be QAM write_output("rho2_mrc.m","rho2_0",<e_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be almost 0 - } */ + } */ } @@ -748,7 +773,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, switch (dlsch0_harq->Qm) { case 2 : - if (rx_type==rx_standard) { + if ((rx_type==rx_standard) || (codeword_TB0 = 1)) { dlsch_qpsk_llr(frame_parms, lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, lte_ue_pdsch_vars[eNB_id]->llr[0], @@ -824,7 +849,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, } break; case 4 : - if (rx_type==rx_standard) { + if ((rx_type==rx_standard ) || (codeword_TB0 = 1) ) { dlsch_16qam_llr(frame_parms, lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, lte_ue_pdsch_vars[eNB_id]->llr[0], @@ -833,7 +858,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,4,subframe,symbol), lte_ue_pdsch_vars[eNB_id]->llr128); } - else if (rx_type >= rx_IC_single_stream) { + else if ((rx_type >= rx_IC_single_stream) && (codeword_TB0 != -1)) { if (dlsch1_harq->Qm == 2) { dlsch_16qam_qpsk_llr(frame_parms, lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, @@ -857,57 +882,57 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, } } else if (dlsch1_harq->Qm == 4) { - dlsch_16qam_16qam_llr(frame_parms, - lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, - rxdataF_comp_ptr,//i - lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0, - dl_ch_mag_ptr,//i - lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext, - lte_ue_pdsch_vars[eNB_id]->llr[0], - symbol,first_symbol_flag,nb_rb, - adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,4,subframe,symbol), - lte_ue_pdsch_vars[eNB_id]->llr128); - if (rx_type==rx_IC_dual_stream) { - dlsch_16qam_16qam_llr(frame_parms, - rxdataF_comp_ptr, - lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,//i - dl_ch_mag_ptr, - lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,//i - lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round], - lte_ue_pdsch_vars[eNB_id]->llr[1], - symbol,first_symbol_flag,nb_rb, - adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,4,subframe,symbol), - lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream); - } + dlsch_16qam_16qam_llr(frame_parms, + lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, + rxdataF_comp_ptr,//i + lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0, + dl_ch_mag_ptr,//i + lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext, + lte_ue_pdsch_vars[eNB_id]->llr[0], + symbol,first_symbol_flag,nb_rb, + adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,4,subframe,symbol), + lte_ue_pdsch_vars[eNB_id]->llr128); + if (rx_type==rx_IC_dual_stream) { + dlsch_16qam_16qam_llr(frame_parms, + rxdataF_comp_ptr, + lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,//i + dl_ch_mag_ptr, + lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,//i + lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round], + lte_ue_pdsch_vars[eNB_id]->llr[1], + symbol,first_symbol_flag,nb_rb, + adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,4,subframe,symbol), + lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream); + } } else { - dlsch_16qam_64qam_llr(frame_parms, - lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, - rxdataF_comp_ptr,//i - lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0, - dl_ch_mag_ptr,//i - lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext, - lte_ue_pdsch_vars[eNB_id]->llr[0], - symbol,first_symbol_flag,nb_rb, - adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,4,subframe,symbol), - lte_ue_pdsch_vars[eNB_id]->llr128); - if (rx_type==rx_IC_dual_stream) { - dlsch_64qam_16qam_llr(frame_parms, - rxdataF_comp_ptr, - lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, - dl_ch_mag_ptr, - lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0, - lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round], - lte_ue_pdsch_vars[eNB_id]->llr[1], - symbol,first_symbol_flag,nb_rb, - adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,6,subframe,symbol), - lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream); - } + dlsch_16qam_64qam_llr(frame_parms, + lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, + rxdataF_comp_ptr,//i + lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0, + dl_ch_mag_ptr,//i + lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext, + lte_ue_pdsch_vars[eNB_id]->llr[0], + symbol,first_symbol_flag,nb_rb, + adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,4,subframe,symbol), + lte_ue_pdsch_vars[eNB_id]->llr128); + if (rx_type==rx_IC_dual_stream) { + dlsch_64qam_16qam_llr(frame_parms, + rxdataF_comp_ptr, + lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, + dl_ch_mag_ptr, + lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0, + lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round], + lte_ue_pdsch_vars[eNB_id]->llr[1], + symbol,first_symbol_flag,nb_rb, + adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,6,subframe,symbol), + lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream); + } } } break; case 6 : - if (rx_type==rx_standard) { + if ((rx_type==rx_standard) || (codeword_TB0 == -1)) { dlsch_64qam_llr(frame_parms, lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, lte_ue_pdsch_vars[eNB_id]->llr[0], @@ -917,76 +942,76 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue, adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,6,subframe,symbol), lte_ue_pdsch_vars[eNB_id]->llr128); } - else if (rx_type >= rx_IC_single_stream) { + else if ((rx_type >= rx_IC_single_stream) && (codeword_TB0 != -1)){ if (dlsch1_harq->Qm == 2) { - dlsch_64qam_qpsk_llr(frame_parms, - lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, - rxdataF_comp_ptr,//i - lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0, - lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext, - lte_ue_pdsch_vars[eNB_id]->llr[0], - symbol,first_symbol_flag,nb_rb, - adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,6,subframe,symbol), - lte_ue_pdsch_vars[eNB_id]->llr128); - if (rx_type==rx_IC_dual_stream) { - dlsch_qpsk_64qam_llr(frame_parms, - rxdataF_comp_ptr, - lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,//i - lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0, - lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round], - lte_ue_pdsch_vars[eNB_id]->llr[1], - symbol,first_symbol_flag,nb_rb, - adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,2,subframe,symbol), - lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream); - } + dlsch_64qam_qpsk_llr(frame_parms, + lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, + rxdataF_comp_ptr,//i + lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0, + lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext, + lte_ue_pdsch_vars[eNB_id]->llr[0], + symbol,first_symbol_flag,nb_rb, + adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,6,subframe,symbol), + lte_ue_pdsch_vars[eNB_id]->llr128); + if (rx_type==rx_IC_dual_stream) { + dlsch_qpsk_64qam_llr(frame_parms, + rxdataF_comp_ptr, + lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,//i + lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0, + lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round], + lte_ue_pdsch_vars[eNB_id]->llr[1], + symbol,first_symbol_flag,nb_rb, + adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,2,subframe,symbol), + lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream); + } } else if (dlsch1_harq->Qm == 4) { - dlsch_64qam_16qam_llr(frame_parms, - lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, - rxdataF_comp_ptr,//i - lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0, - dl_ch_mag_ptr,//i - lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext, - lte_ue_pdsch_vars[eNB_id]->llr[0], - symbol,first_symbol_flag,nb_rb, - adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,6,subframe,symbol), - lte_ue_pdsch_vars[eNB_id]->llr128); - if (rx_type==rx_IC_dual_stream) { - dlsch_16qam_64qam_llr(frame_parms, - rxdataF_comp_ptr, - lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,//i - dl_ch_mag_ptr, - lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,//i - lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round], - lte_ue_pdsch_vars[eNB_id]->llr[1], - symbol,first_symbol_flag,nb_rb, - adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,4,subframe,symbol), - lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream); - } + dlsch_64qam_16qam_llr(frame_parms, + lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, + rxdataF_comp_ptr,//i + lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0, + dl_ch_mag_ptr,//i + lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext, + lte_ue_pdsch_vars[eNB_id]->llr[0], + symbol,first_symbol_flag,nb_rb, + adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,6,subframe,symbol), + lte_ue_pdsch_vars[eNB_id]->llr128); + if (rx_type==rx_IC_dual_stream) { + dlsch_16qam_64qam_llr(frame_parms, + rxdataF_comp_ptr, + lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,//i + dl_ch_mag_ptr, + lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,//i + lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round], + lte_ue_pdsch_vars[eNB_id]->llr[1], + symbol,first_symbol_flag,nb_rb, + adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,4,subframe,symbol), + lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream); + } } else { - dlsch_64qam_64qam_llr(frame_parms, - lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, - rxdataF_comp_ptr,//i - lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0, - dl_ch_mag_ptr,//i - lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext, - lte_ue_pdsch_vars[eNB_id]->llr[0], - symbol,first_symbol_flag,nb_rb, - adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,6,subframe,symbol), - lte_ue_pdsch_vars[eNB_id]->llr128); - if (rx_type==rx_IC_dual_stream) { - dlsch_64qam_64qam_llr(frame_parms, - rxdataF_comp_ptr, - lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,//i - dl_ch_mag_ptr, - lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,//i - lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round], - lte_ue_pdsch_vars[eNB_id]->llr[1], - symbol,first_symbol_flag,nb_rb, - adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,6,subframe,symbol), - lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream); - } + dlsch_64qam_64qam_llr(frame_parms, + lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, + rxdataF_comp_ptr,//i + lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0, + dl_ch_mag_ptr,//i + lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext, + lte_ue_pdsch_vars[eNB_id]->llr[0], + symbol,first_symbol_flag,nb_rb, + adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,6,subframe,symbol), + lte_ue_pdsch_vars[eNB_id]->llr128); + if (rx_type==rx_IC_dual_stream) { + dlsch_64qam_64qam_llr(frame_parms, + rxdataF_comp_ptr, + lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,//i + dl_ch_mag_ptr, + lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,//i + lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round], + lte_ue_pdsch_vars[eNB_id]->llr[1], + symbol,first_symbol_flag,nb_rb, + adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,6,subframe,symbol), + lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream); + } } } @@ -1689,7 +1714,7 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext, Nre = (pilots==0) ? 12 : 8; precoded_signal_strength += ((signal_energy_nodc(&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*Nre], - (nb_rb*Nre))) - (phy_measurements->n0_power[aarx])); + (nb_rb*Nre))) - (phy_measurements->n0_power[aarx])); } // rx_antennas phy_measurements->precoded_cqi_dB[eNB_id][0] = dB_fixed2(precoded_signal_strength,phy_measurements->n0_power_tot); @@ -1754,51 +1779,51 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext, prec2A_TM56_128(pmi_ext[rb],&dl_ch0_128b[1],&dl_ch1_128b[1]); if (pilots==0) { - prec2A_TM56_128(pmi_ext[rb],&dl_ch0_128b[2],&dl_ch1_128b[2]); + prec2A_TM56_128(pmi_ext[rb],&dl_ch0_128b[2],&dl_ch1_128b[2]); } if (mod_order>2) { - // get channel amplitude if not QPSK - mmtmpD0 = vmull_s16(dl_ch0_128[0], dl_ch0_128[0]); - // mmtmpD0 = [ch0*ch0,ch1*ch1,ch2*ch2,ch3*ch3]; - mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); - // mmtmpD0 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3]>>output_shift128 on 32-bits - mmtmpD1 = vmull_s16(dl_ch0_128[1], dl_ch0_128[1]); - mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); - mmtmpD2 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); - // mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits - mmtmpD0 = vmull_s16(dl_ch0_128[2], dl_ch0_128[2]); - mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); - mmtmpD1 = vmull_s16(dl_ch0_128[3], dl_ch0_128[3]); - mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); - mmtmpD3 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); - if (pilots==0) { - mmtmpD0 = vmull_s16(dl_ch0_128[4], dl_ch0_128[4]); - mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); - mmtmpD1 = vmull_s16(dl_ch0_128[5], dl_ch0_128[5]); - mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); - mmtmpD4 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); - - - } - - dl_ch_mag128b[0] = vqdmulhq_s16(mmtmpD2,QAM_amp128b); - dl_ch_mag128b[1] = vqdmulhq_s16(mmtmpD3,QAM_amp128b); - dl_ch_mag128[0] = vqdmulhq_s16(mmtmpD2,QAM_amp128); - dl_ch_mag128[1] = vqdmulhq_s16(mmtmpD3,QAM_amp128); - - - if (pilots==0) { - dl_ch_mag128b[2] = vqdmulhq_s16(mmtmpD4,QAM_amp128b); - dl_ch_mag128[2] = vqdmulhq_s16(mmtmpD4,QAM_amp128); - } + // get channel amplitude if not QPSK + mmtmpD0 = vmull_s16(dl_ch0_128[0], dl_ch0_128[0]); + // mmtmpD0 = [ch0*ch0,ch1*ch1,ch2*ch2,ch3*ch3]; + mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); + // mmtmpD0 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3]>>output_shift128 on 32-bits + mmtmpD1 = vmull_s16(dl_ch0_128[1], dl_ch0_128[1]); + mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); + mmtmpD2 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); + // mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits + mmtmpD0 = vmull_s16(dl_ch0_128[2], dl_ch0_128[2]); + mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); + mmtmpD1 = vmull_s16(dl_ch0_128[3], dl_ch0_128[3]); + mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); + mmtmpD3 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); + if (pilots==0) { + mmtmpD0 = vmull_s16(dl_ch0_128[4], dl_ch0_128[4]); + mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); + mmtmpD1 = vmull_s16(dl_ch0_128[5], dl_ch0_128[5]); + mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); + mmtmpD4 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); + + + } + + dl_ch_mag128b[0] = vqdmulhq_s16(mmtmpD2,QAM_amp128b); + dl_ch_mag128b[1] = vqdmulhq_s16(mmtmpD3,QAM_amp128b); + dl_ch_mag128[0] = vqdmulhq_s16(mmtmpD2,QAM_amp128); + dl_ch_mag128[1] = vqdmulhq_s16(mmtmpD3,QAM_amp128); + + + if (pilots==0) { + dl_ch_mag128b[2] = vqdmulhq_s16(mmtmpD4,QAM_amp128b); + dl_ch_mag128[2] = vqdmulhq_s16(mmtmpD4,QAM_amp128); + } } mmtmpD0 = vmull_s16(dl_ch0_128[0], rxdataF128[0]); //mmtmpD0 = [Re(ch[0])Re(rx[0]) Im(ch[0])Im(ch[0]) Re(ch[1])Re(rx[1]) Im(ch[1])Im(ch[1])] mmtmpD1 = vmull_s16(dl_ch0_128[1], rxdataF128[1]); //mmtmpD1 = [Re(ch[2])Re(rx[2]) Im(ch[2])Im(ch[2]) Re(ch[3])Re(rx[3]) Im(ch[3])Im(ch[3])] mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)), - vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); + vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); //mmtmpD0 = [Re(ch[0])Re(rx[0])+Im(ch[0])Im(ch[0]) Re(ch[1])Re(rx[1])+Im(ch[1])Im(ch[1]) Re(ch[2])Re(rx[2])+Im(ch[2])Im(ch[2]) Re(ch[3])Re(rx[3])+Im(ch[3])Im(ch[3])] mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[0],*(int16x4_t*)conj)), rxdataF128[0]); @@ -1806,7 +1831,7 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext, mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[1],*(int16x4_t*)conj)), rxdataF128[1]); //mmtmpD0 = [-Im(ch[2])Re(rx[2]) Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3]) Re(ch[3])Im(rx[3])] mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)), - vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); + vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); //mmtmpD1 = [-Im(ch[0])Re(rx[0])+Re(ch[0])Im(rx[0]) -Im(ch[1])Re(rx[1])+Re(ch[1])Im(rx[1]) -Im(ch[2])Re(rx[2])+Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3])+Re(ch[3])Im(rx[3])] mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128); @@ -1816,48 +1841,48 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext, mmtmpD0 = vmull_s16(dl_ch0_128[2], rxdataF128[2]); mmtmpD1 = vmull_s16(dl_ch0_128[3], rxdataF128[3]); mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)), - vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); + vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[2],*(int16x4_t*)conj)), rxdataF128[2]); mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[3],*(int16x4_t*)conj)), rxdataF128[3]); mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)), - vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); + vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128); mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128); rxdataF_comp128[1] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); if (pilots==0) { - mmtmpD0 = vmull_s16(dl_ch0_128[4], rxdataF128[4]); - mmtmpD1 = vmull_s16(dl_ch0_128[5], rxdataF128[5]); - mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)), - vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); + mmtmpD0 = vmull_s16(dl_ch0_128[4], rxdataF128[4]); + mmtmpD1 = vmull_s16(dl_ch0_128[5], rxdataF128[5]); + mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)), + vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); - mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[4],*(int16x4_t*)conj)), rxdataF128[4]); - mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[5],*(int16x4_t*)conj)), rxdataF128[5]); - mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)), - vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); + mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[4],*(int16x4_t*)conj)), rxdataF128[4]); + mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[5],*(int16x4_t*)conj)), rxdataF128[5]); + mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)), + vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); - mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128); - mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128); - rxdataF_comp128[2] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); + mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128); + mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128); + rxdataF_comp128[2] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); - dl_ch0_128+=6; - dl_ch1_128+=6; - dl_ch_mag128+=3; - dl_ch_mag128b+=3; - rxdataF128+=6; - rxdataF_comp128+=3; + dl_ch0_128+=6; + dl_ch1_128+=6; + dl_ch_mag128+=3; + dl_ch_mag128b+=3; + rxdataF128+=6; + rxdataF_comp128+=3; } else { // we have a smaller PDSCH in symbols with pilots so skip last group of 4 REs and increment less - dl_ch0_128+=4; - dl_ch1_128+=4; - dl_ch_mag128+=2; - dl_ch_mag128b+=2; - rxdataF128+=4; - rxdataF_comp128+=2; + dl_ch0_128+=4; + dl_ch1_128+=4; + dl_ch_mag128+=2; + dl_ch_mag128b+=2; + rxdataF128+=4; + rxdataF_comp128+=2; } } @@ -1865,7 +1890,7 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext, precoded_signal_strength += ((signal_energy_nodc(&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*Nre], - (nb_rb*Nre))) - (phy_measurements->n0_power[aarx])); + (nb_rb*Nre))) - (phy_measurements->n0_power[aarx])); // rx_antennas } phy_measurements->precoded_cqi_dB[eNB_id][0] = dB_fixed2(precoded_signal_strength,phy_measurements->n0_power_tot); @@ -1890,7 +1915,7 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms, MIMO_mode_t mimo_mode, unsigned short nb_rb, unsigned char output_shift0, - unsigned char output_shift1) { + unsigned char output_shift1) { #if defined(__x86_64__) || defined(__i386__) @@ -1943,7 +1968,7 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms, output_shift=output_shift0; } else { - output_shift=output_shift1; + output_shift=output_shift1; } */ // printf("antenna %d\n", aarx); @@ -2384,79 +2409,79 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms, if (mod_order0>2) { - // get channel amplitude if not QPSK - mmtmpD0 = vmull_s16(dl_ch0_128[0], dl_ch0_128[0]); - // mmtmpD0 = [ch0*ch0,ch1*ch1,ch2*ch2,ch3*ch3]; - mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); - // mmtmpD0 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3]>>output_shift128 on 32-bits - mmtmpD1 = vmull_s16(dl_ch0_128[1], dl_ch0_128[1]); - mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); - mmtmpD2 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); - // mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits - mmtmpD0 = vmull_s16(dl_ch0_128[2], dl_ch0_128[2]); - mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); - mmtmpD1 = vmull_s16(dl_ch0_128[3], dl_ch0_128[3]); - mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); - mmtmpD3 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); - - if (pilots==0) { - mmtmpD0 = vmull_s16(dl_ch0_128[4], dl_ch0_128[4]); - mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); - mmtmpD1 = vmull_s16(dl_ch0_128[5], dl_ch0_128[5]); - mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); - mmtmpD4 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); - - - } - - dl_ch_mag0_128b[0] = vqdmulhq_s16(mmtmpD2,QAM_amp0_128b); - dl_ch_mag0_128b[1] = vqdmulhq_s16(mmtmpD3,QAM_amp0_128b); - dl_ch_mag0_128[0] = vqdmulhq_s16(mmtmpD2,QAM_amp0_128); - dl_ch_mag0_128[1] = vqdmulhq_s16(mmtmpD3,QAM_amp0_128); - - - if (pilots==0) { - dl_ch_mag0_128b[2] = vqdmulhq_s16(mmtmpD4,QAM_amp0_128b); - dl_ch_mag0_128[2] = vqdmulhq_s16(mmtmpD4,QAM_amp0_128); - } + // get channel amplitude if not QPSK + mmtmpD0 = vmull_s16(dl_ch0_128[0], dl_ch0_128[0]); + // mmtmpD0 = [ch0*ch0,ch1*ch1,ch2*ch2,ch3*ch3]; + mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); + // mmtmpD0 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3]>>output_shift128 on 32-bits + mmtmpD1 = vmull_s16(dl_ch0_128[1], dl_ch0_128[1]); + mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); + mmtmpD2 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); + // mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits + mmtmpD0 = vmull_s16(dl_ch0_128[2], dl_ch0_128[2]); + mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); + mmtmpD1 = vmull_s16(dl_ch0_128[3], dl_ch0_128[3]); + mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); + mmtmpD3 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); + + if (pilots==0) { + mmtmpD0 = vmull_s16(dl_ch0_128[4], dl_ch0_128[4]); + mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); + mmtmpD1 = vmull_s16(dl_ch0_128[5], dl_ch0_128[5]); + mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); + mmtmpD4 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); + + + } + + dl_ch_mag0_128b[0] = vqdmulhq_s16(mmtmpD2,QAM_amp0_128b); + dl_ch_mag0_128b[1] = vqdmulhq_s16(mmtmpD3,QAM_amp0_128b); + dl_ch_mag0_128[0] = vqdmulhq_s16(mmtmpD2,QAM_amp0_128); + dl_ch_mag0_128[1] = vqdmulhq_s16(mmtmpD3,QAM_amp0_128); + + + if (pilots==0) { + dl_ch_mag0_128b[2] = vqdmulhq_s16(mmtmpD4,QAM_amp0_128b); + dl_ch_mag0_128[2] = vqdmulhq_s16(mmtmpD4,QAM_amp0_128); + } } if (mod_order1>2) { - // get channel amplitude if not QPSK - mmtmpD0 = vmull_s16(dl_ch1_128[0], dl_ch1_128[0]); - // mmtmpD0 = [ch0*ch0,ch1*ch1,ch2*ch2,ch3*ch3]; - mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); - // mmtmpD0 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3]>>output_shift128 on 32-bits - mmtmpD1 = vmull_s16(dl_ch1_128[1], dl_ch1_128[1]); - mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); - mmtmpD2 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); - // mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits - mmtmpD0 = vmull_s16(dl_ch1_128[2], dl_ch1_128[2]); - mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); - mmtmpD1 = vmull_s16(dl_ch1_128[3], dl_ch1_128[3]); - mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); - mmtmpD3 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); - - if (pilots==0) { - mmtmpD0 = vmull_s16(dl_ch1_128[4], dl_ch1_128[4]); - mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); - mmtmpD1 = vmull_s16(dl_ch1_128[5], dl_ch1_128[5]); - mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); - mmtmpD4 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); - - - } - - dl_ch_mag1_128b[0] = vqdmulhq_s16(mmtmpD2,QAM_amp1_128b); - dl_ch_mag1_128b[1] = vqdmulhq_s16(mmtmpD3,QAM_amp1_128b); - dl_ch_mag1_128[0] = vqdmulhq_s16(mmtmpD2,QAM_amp1_128); - dl_ch_mag1_128[1] = vqdmulhq_s16(mmtmpD3,QAM_amp1_128); - - - if (pilots==0) { - dl_ch_mag1_128b[2] = vqdmulhq_s16(mmtmpD4,QAM_amp1_128b); - dl_ch_mag1_128[2] = vqdmulhq_s16(mmtmpD4,QAM_amp1_128); - } + // get channel amplitude if not QPSK + mmtmpD0 = vmull_s16(dl_ch1_128[0], dl_ch1_128[0]); + // mmtmpD0 = [ch0*ch0,ch1*ch1,ch2*ch2,ch3*ch3]; + mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); + // mmtmpD0 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3]>>output_shift128 on 32-bits + mmtmpD1 = vmull_s16(dl_ch1_128[1], dl_ch1_128[1]); + mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); + mmtmpD2 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); + // mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits + mmtmpD0 = vmull_s16(dl_ch1_128[2], dl_ch1_128[2]); + mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); + mmtmpD1 = vmull_s16(dl_ch1_128[3], dl_ch1_128[3]); + mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); + mmtmpD3 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); + + if (pilots==0) { + mmtmpD0 = vmull_s16(dl_ch1_128[4], dl_ch1_128[4]); + mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128); + mmtmpD1 = vmull_s16(dl_ch1_128[5], dl_ch1_128[5]); + mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128); + mmtmpD4 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); + + + } + + dl_ch_mag1_128b[0] = vqdmulhq_s16(mmtmpD2,QAM_amp1_128b); + dl_ch_mag1_128b[1] = vqdmulhq_s16(mmtmpD3,QAM_amp1_128b); + dl_ch_mag1_128[0] = vqdmulhq_s16(mmtmpD2,QAM_amp1_128); + dl_ch_mag1_128[1] = vqdmulhq_s16(mmtmpD3,QAM_amp1_128); + + + if (pilots==0) { + dl_ch_mag1_128b[2] = vqdmulhq_s16(mmtmpD4,QAM_amp1_128b); + dl_ch_mag1_128[2] = vqdmulhq_s16(mmtmpD4,QAM_amp1_128); + } } mmtmpD0 = vmull_s16(dl_ch0_128[0], rxdataF128[0]); @@ -2464,7 +2489,7 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms, mmtmpD1 = vmull_s16(dl_ch0_128[1], rxdataF128[1]); //mmtmpD1 = [Re(ch[2])Re(rx[2]) Im(ch[2])Im(ch[2]) Re(ch[3])Re(rx[3]) Im(ch[3])Im(ch[3])] mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)), - vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); + vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); //mmtmpD0 = [Re(ch[0])Re(rx[0])+Im(ch[0])Im(ch[0]) Re(ch[1])Re(rx[1])+Im(ch[1])Im(ch[1]) Re(ch[2])Re(rx[2])+Im(ch[2])Im(ch[2]) Re(ch[3])Re(rx[3])+Im(ch[3])Im(ch[3])] mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[0],*(int16x4_t*)conj)), rxdataF128[0]); @@ -2472,7 +2497,7 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms, mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[1],*(int16x4_t*)conj)), rxdataF128[1]); //mmtmpD0 = [-Im(ch[2])Re(rx[2]) Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3]) Re(ch[3])Im(rx[3])] mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)), - vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); + vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); //mmtmpD1 = [-Im(ch[0])Re(rx[0])+Re(ch[0])Im(rx[0]) -Im(ch[1])Re(rx[1])+Re(ch[1])Im(rx[1]) -Im(ch[2])Re(rx[2])+Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3])+Re(ch[3])Im(rx[3])] mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128); @@ -2482,12 +2507,12 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms, mmtmpD0 = vmull_s16(dl_ch0_128[2], rxdataF128[2]); mmtmpD1 = vmull_s16(dl_ch0_128[3], rxdataF128[3]); mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)), - vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); + vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[2],*(int16x4_t*)conj)), rxdataF128[2]); mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[3],*(int16x4_t*)conj)), rxdataF128[3]); mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)), - vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); + vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128); mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128); @@ -2497,13 +2522,13 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms, mmtmpD0 = vmull_s16(dl_ch1_128[0], rxdataF128[0]); mmtmpD1 = vmull_s16(dl_ch1_128[1], rxdataF128[1]); mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)), - vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); + vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[0],*(int16x4_t*)conj)), rxdataF128[0]); mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[1],*(int16x4_t*)conj)), rxdataF128[1]); //mmtmpD0 = [-Im(ch[2])Re(rx[2]) Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3]) Re(ch[3])Im(rx[3])] mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)), - vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); + vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); //mmtmpD1 = [-Im(ch[0])Re(rx[0])+Re(ch[0])Im(rx[0]) -Im(ch[1])Re(rx[1])+Re(ch[1])Im(rx[1]) -Im(ch[2])Re(rx[2])+Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3])+Re(ch[3])Im(rx[3])] mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128); @@ -2513,46 +2538,46 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms, mmtmpD0 = vmull_s16(dl_ch1_128[2], rxdataF128[2]); mmtmpD1 = vmull_s16(dl_ch1_128[3], rxdataF128[3]); mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)), - vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); + vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[2],*(int16x4_t*)conj)), rxdataF128[2]); mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[3],*(int16x4_t*)conj)), rxdataF128[3]); mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)), - vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); + vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128); mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128); rxdataF_comp1_128[1] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); if (pilots==0) { - mmtmpD0 = vmull_s16(dl_ch0_128[4], rxdataF128[4]); - mmtmpD1 = vmull_s16(dl_ch0_128[5], rxdataF128[5]); - mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)), - vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); - - mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[4],*(int16x4_t*)conj)), rxdataF128[4]); - mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[5],*(int16x4_t*)conj)), rxdataF128[5]); - mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)), - vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); - - - mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128); - mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128); - rxdataF_comp0_128[2] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); - mmtmpD0 = vmull_s16(dl_ch1_128[4], rxdataF128[4]); - mmtmpD1 = vmull_s16(dl_ch1_128[5], rxdataF128[5]); - mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)), - vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); - - mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch1_128[4],*(int16x4_t*)conj)), rxdataF128[4]); - mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch1_128[5],*(int16x4_t*)conj)), rxdataF128[5]); - mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)), - vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); - - - mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128); - mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128); - rxdataF_comp1_128[2] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); + mmtmpD0 = vmull_s16(dl_ch0_128[4], rxdataF128[4]); + mmtmpD1 = vmull_s16(dl_ch0_128[5], rxdataF128[5]); + mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)), + vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); + + mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[4],*(int16x4_t*)conj)), rxdataF128[4]); + mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[5],*(int16x4_t*)conj)), rxdataF128[5]); + mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)), + vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); + + + mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128); + mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128); + rxdataF_comp0_128[2] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); + mmtmpD0 = vmull_s16(dl_ch1_128[4], rxdataF128[4]); + mmtmpD1 = vmull_s16(dl_ch1_128[5], rxdataF128[5]); + mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)), + vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1))); + + mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch1_128[4],*(int16x4_t*)conj)), rxdataF128[4]); + mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch1_128[5],*(int16x4_t*)conj)), rxdataF128[5]); + mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)), + vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b))); + + + mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128); + mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128); + rxdataF_comp1_128[2] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1)); } } @@ -2700,7 +2725,7 @@ void dlsch_dual_stream_correlation(LTE_DL_FRAME_PARMS *frame_parms, int **dl_ch_estimates_ext_i, int **dl_ch_rho_ext, unsigned char output_shift0, - unsigned char output_shift1) + unsigned char output_shift1) { #if defined(__x86_64__)||defined(__i386__) @@ -2726,7 +2751,7 @@ void dlsch_dual_stream_correlation(LTE_DL_FRAME_PARMS *frame_parms, output_shift=output_shift0; } else { - output_shift=output_shift1; + output_shift=output_shift1; } //printf ("antenna %d", aarx); @@ -2852,8 +2877,8 @@ void dlsch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms, dl_ch_mag128_0[i] = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_0[i],1),_mm_srai_epi16(dl_ch_mag128_1[i],1)); dl_ch_mag128_0b[i] = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_0b[i],1),_mm_srai_epi16(dl_ch_mag128_1b[i],1)); // print_shorts("mrc comp0:",&rxdataF_comp128_0[i]); - // print_shorts("mrc mag0:",&dl_ch_mag128_0[i]); - // print_shorts("mrc mag0b:",&dl_ch_mag128_0b[i]); + // print_shorts("mrc mag0:",&dl_ch_mag128_0[i]); + // print_shorts("mrc mag0b:",&dl_ch_mag128_0b[i]); // print_shorts("mrc rho1:",&rho128_1[i]); } @@ -2956,25 +2981,25 @@ void dlsch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms, void dlsch_detection_mrc_TM34(LTE_DL_FRAME_PARMS *frame_parms, - LTE_UE_PDSCH *lte_ue_pdsch_vars, - int harq_pid, - int round, - unsigned char symbol, - unsigned short nb_rb, - unsigned char dual_stream_UE) { + LTE_UE_PDSCH *lte_ue_pdsch_vars, + int harq_pid, + int round, + unsigned char symbol, + unsigned short nb_rb, + unsigned char dual_stream_UE) { unsigned char aatx; int i; __m128i *rxdataF_comp128_0,*rxdataF_comp128_1,*rxdataF_comp128_i0,*rxdataF_comp128_i1,*dl_ch_mag128_0,*dl_ch_mag128_1,*dl_ch_mag128_0b,*dl_ch_mag128_1b,*rho128_0,*rho128_1,*rho128_i0,*rho128_i1,*dl_ch_mag128_i0,*dl_ch_mag128_i1,*dl_ch_mag128_i0b,*dl_ch_mag128_i1b; - int **rxdataF_comp0 =lte_ue_pdsch_vars->rxdataF_comp0; - int **rxdataF_comp1 =lte_ue_pdsch_vars->rxdataF_comp1[harq_pid][round]; - int **dl_ch_rho_ext =lte_ue_pdsch_vars->dl_ch_rho_ext[harq_pid][round]; //for second stream - int **dl_ch_rho2_ext =lte_ue_pdsch_vars->dl_ch_rho2_ext; - int **dl_ch_mag0 = lte_ue_pdsch_vars->dl_ch_mag0; - int **dl_ch_mag1 = lte_ue_pdsch_vars->dl_ch_mag1[harq_pid][round]; - int **dl_ch_magb0 = lte_ue_pdsch_vars->dl_ch_magb0; - int **dl_ch_magb1 = lte_ue_pdsch_vars->dl_ch_magb1[harq_pid][round]; + int **rxdataF_comp0 =lte_ue_pdsch_vars->rxdataF_comp0; + int **rxdataF_comp1 =lte_ue_pdsch_vars->rxdataF_comp1[harq_pid][round]; + int **dl_ch_rho_ext =lte_ue_pdsch_vars->dl_ch_rho_ext[harq_pid][round]; //for second stream + int **dl_ch_rho2_ext =lte_ue_pdsch_vars->dl_ch_rho2_ext; + int **dl_ch_mag0 = lte_ue_pdsch_vars->dl_ch_mag0; + int **dl_ch_mag1 = lte_ue_pdsch_vars->dl_ch_mag1[harq_pid][round]; + int **dl_ch_magb0 = lte_ue_pdsch_vars->dl_ch_magb0; + int **dl_ch_magb1 = lte_ue_pdsch_vars->dl_ch_magb1[harq_pid][round]; if (frame_parms->nb_antennas_rx>1) { @@ -2992,9 +3017,9 @@ void dlsch_detection_mrc_TM34(LTE_DL_FRAME_PARMS *frame_parms, dl_ch_mag128_0[i] = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_0[i],1),_mm_srai_epi16(dl_ch_mag128_1[i],1)); dl_ch_mag128_0b[i] = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_0b[i],1),_mm_srai_epi16(dl_ch_mag128_1b[i],1)); - // print_shorts("mrc compens0:",&rxdataF_comp128_0[i]); - // print_shorts("mrc mag128_0:",&dl_ch_mag128_0[i]); - // print_shorts("mrc mag128_0b:",&dl_ch_mag128_0b[i]); + // print_shorts("mrc compens0:",&rxdataF_comp128_0[i]); + // print_shorts("mrc mag128_0:",&dl_ch_mag128_0[i]); + // print_shorts("mrc mag128_0b:",&dl_ch_mag128_0b[i]); } } // if (rho) { @@ -3024,9 +3049,9 @@ void dlsch_detection_mrc_TM34(LTE_DL_FRAME_PARMS *frame_parms, dl_ch_mag128_i0[i] = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_i0[i],1),_mm_srai_epi16(dl_ch_mag128_i1[i],1)); dl_ch_mag128_i0b[i] = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_i0b[i],1),_mm_srai_epi16(dl_ch_mag128_i1b[i],1)); - //print_shorts("mrc compens1:",&rxdataF_comp128_i0[i]); - //print_shorts("mrc mag128_i0:",&dl_ch_mag128_i0[i]); - //print_shorts("mrc mag128_i0b:",&dl_ch_mag128_i0b[i]); + //print_shorts("mrc compens1:",&rxdataF_comp128_i0[i]); + //print_shorts("mrc mag128_i0:",&dl_ch_mag128_i0[i]); + //print_shorts("mrc mag128_i0b:",&dl_ch_mag128_i0b[i]); } } @@ -3228,9 +3253,9 @@ void dlsch_channel_level(int **dl_ch_estimates_ext, //compute average channel_level of effective (precoded) channel void dlsch_channel_level_TM34(int **dl_ch_estimates_ext, LTE_DL_FRAME_PARMS *frame_parms, - unsigned char *pmi_ext, + unsigned char *pmi_ext, int *avg_0, - int *avg_1, + int *avg_1, uint8_t symbol, unsigned short nb_rb, MIMO_mode_t mimo_mode){ @@ -3269,7 +3294,7 @@ void dlsch_channel_level_TM34(int **dl_ch_estimates_ext, for (rb=0; rb<nb_rb; rb++) { // printf("rb %d : \n",rb); // print_shorts("ch0\n",&dl_ch0_128[0]); - //print_shorts("ch1\n",&dl_ch1_128[0]); + //print_shorts("ch1\n",&dl_ch1_128[0]); dl_ch0_128_tmp = _mm_load_si128(&dl_ch0_128[0]); dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[0]); @@ -3318,12 +3343,12 @@ void dlsch_channel_level_TM34(int **dl_ch_estimates_ext, prec2A_TM4_128(0,&dl_ch0_128_tmp,&dl_ch1_128_tmp); else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODINGj) prec2A_TM4_128(1,&dl_ch0_128_tmp,&dl_ch1_128_tmp); - else if (mimo_mode==DUALSTREAM_PUSCH_PRECODING) - prec2A_TM4_128(pmi_ext[rb],&dl_ch0_128_tmp,&dl_ch1_128_tmp); + else if (mimo_mode==DUALSTREAM_PUSCH_PRECODING) + prec2A_TM4_128(pmi_ext[rb],&dl_ch0_128_tmp,&dl_ch1_128_tmp); // mmtmpD2 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp); - avg_1_128D = _mm_add_epi32(avg_1_128D,_mm_madd_epi16(dl_ch1_128_tmp,dl_ch1_128_tmp)); - avg_0_128D = _mm_add_epi32(avg_0_128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp)); + avg_1_128D = _mm_add_epi32(avg_1_128D,_mm_madd_epi16(dl_ch1_128_tmp,dl_ch1_128_tmp)); + avg_0_128D = _mm_add_epi32(avg_0_128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp)); dl_ch0_128+=3; dl_ch1_128+=3; @@ -3720,7 +3745,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, else rb_alloc_ind = 0; - if (rb_alloc_ind == 1) + if (rb_alloc_ind == 1) nb_rb++; // For second half of RBs skip DC carrier @@ -3759,17 +3784,17 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int)); /* - printf("rb %d\n",rb); - for (i=0;i<12;i++) - printf("(%d %d)",((short *)dl_ch0)[i<<1],((short*)dl_ch0)[1+(i<<1)]); - printf("\n"); + printf("rb %d\n",rb); + for (i=0;i<12;i++) + printf("(%d %d)",((short *)dl_ch0)[i<<1],((short*)dl_ch0)[1+(i<<1)]); + printf("\n"); */ if (pilots==0) { for (i=0; i<12; i++) { rxF_ext[i]=rxF[i]; /* - printf("%d : (%d,%d)\n",(rxF+i-&rxdataF[aarx][( (symbol*(frame_parms->ofdm_symbol_size)))]), - ((short*)&rxF[i])[0],((short*)&rxF[i])[1]);*/ + printf("%d : (%d,%d)\n",(rxF+i-&rxdataF[aarx][( (symbol*(frame_parms->ofdm_symbol_size)))]), + ((short*)&rxF[i])[0],((short*)&rxF[i])[1]);*/ } dl_ch0_ext+=12; @@ -3801,7 +3826,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, else { // Odd number of RBs for (rb=0; rb<frame_parms->N_RB_DL>>1; rb++) { #ifdef DEBUG_DLSCH_DEMOD - printf("dlch_ext %d\n",dl_ch0_ext-&dl_ch_estimates_ext[aarx][0]); + printf("dlch_ext %d\n",dl_ch0_ext-&dl_ch_estimates_ext[aarx][0]); #endif skip_half=0; @@ -3816,8 +3841,8 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, else rb_alloc_ind = 0; - if (rb_alloc_ind == 1) - nb_rb++; + if (rb_alloc_ind == 1) + nb_rb++; // PBCH @@ -3853,9 +3878,9 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, if (frame_parms->frame_type == FDD) { //FDD if (((subframe==0)||(subframe==5)) && - (rb>((frame_parms->N_RB_DL>>1)-3)) && - (rb<((frame_parms->N_RB_DL>>1)+3)) && - (l==pss_symb) ) { + (rb>((frame_parms->N_RB_DL>>1)-3)) && + (rb<((frame_parms->N_RB_DL>>1)+3)) && + (l==pss_symb) ) { rb_alloc_ind = 0; } @@ -3880,19 +3905,19 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, if (rb_alloc_ind==1) { #ifdef DEBUG_DLSCH_DEMOD - printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half); + printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half); #endif if (pilots==0) { - // printf("Extracting w/o pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half); + // printf("Extracting w/o pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half); if (skip_half==1) { memcpy(dl_ch0_ext,dl_ch0,6*sizeof(int)); for (i=0; i<6; i++) { - rxF_ext[i]=rxF[i]; + rxF_ext[i]=rxF[i]; #ifdef DEBUG_DLSCH_DEMOD - printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); + printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); #endif - } + } dl_ch0_ext+=6; rxF_ext+=6; } else if (skip_half==2) { @@ -3901,9 +3926,9 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, for (i=0; i<6; i++) { rxF_ext[i]=rxF[(i+6)]; #ifdef DEBUG_DLSCH_DEMOD - printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); + printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); #endif - } + } dl_ch0_ext+=6; rxF_ext+=6; } else { @@ -3914,12 +3939,12 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, #ifdef DEBUG_DLSCH_DEMOD printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); #endif - } + } dl_ch0_ext+=12; rxF_ext+=12; } } else { - // printf("Extracting with pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half); + // printf("Extracting with pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half); j=0; if (skip_half==1) { @@ -3932,14 +3957,14 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, dl_ch0_ext[j++]=dl_ch0[i]; } } - rxF_ext+=5; + rxF_ext+=5; dl_ch0_ext+=5; } else if (skip_half==2) { for (i=0; i<6; i++) { if (i!=((frame_parms->nushift+poffset)%6)) { rxF_ext[j]=rxF[(i+6)]; #ifdef DEBUG_DLSCH_DEMOD - printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j])); + printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j])); #endif dl_ch0_ext[j++]=dl_ch0[i+6]; } @@ -3953,7 +3978,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, (i!=((frame_parms->nushift+poffset+6)%12))) { rxF_ext[j]=rxF[i]; #ifdef DEBUG_DLSCH_DEMOD - printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j])); + printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j])); #endif dl_ch0_ext[j++]=dl_ch0[i]; @@ -3984,13 +4009,13 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, if (rb_alloc_ind == 1) - nb_rb++; + nb_rb++; // PBCH if ((subframe==0) && - (l>=(nsymb>>1)) && - (l<((nsymb>>1) + 4))) { + (l>=(nsymb>>1)) && + (l<((nsymb>>1) + 4))) { rb_alloc_ind = 0; } @@ -4009,8 +4034,8 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, //PSS if ((frame_parms->frame_type == TDD) && (subframe==6) && - (l==pss_symb) ) { - rb_alloc_ind = 0; + (l==pss_symb) ) { + rb_alloc_ind = 0; } @@ -4018,7 +4043,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, // printf("DC rb %d (%p)\n",rb,rxF); if (rb_alloc_ind==1) { #ifdef DEBUG_DLSCH_DEMOD - printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half); + printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half); #endif if (pilots==0) { for (i=0; i<6; i++) { @@ -4088,8 +4113,8 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, else rb_alloc_ind = 0; - if (rb_alloc_ind == 1) - nb_rb++; + if (rb_alloc_ind == 1) + nb_rb++; // PBCH if ((subframe==0) && (rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l>=nsymb>>1) && (l<((nsymb>>1) + 4))) { @@ -4139,25 +4164,25 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, if (rb_alloc_ind==1) { #ifdef DEBUG_DLSCH_DEMOD - printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half); + printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half); #endif /* - printf("rb %d\n",rb); + printf("rb %d\n",rb); for (i=0;i<12;i++) printf("(%d %d)",((short *)dl_ch0)[i<<1],((short*)dl_ch0)[1+(i<<1)]); printf("\n"); */ if (pilots==0) { - // printf("Extracting w/o pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half); + // printf("Extracting w/o pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half); if (skip_half==1) { memcpy(dl_ch0_ext,dl_ch0,6*sizeof(int)); for (i=0; i<6; i++) { rxF_ext[i]=rxF[i]; #ifdef DEBUG_DLSCH_DEMOD - printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); + printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); #endif - } + } dl_ch0_ext+=6; rxF_ext+=6; @@ -4167,9 +4192,9 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, for (i=0; i<6; i++) { rxF_ext[i]=rxF[(i+6)]; #ifdef DEBUG_DLSCH_DEMOD - printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); + printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); #endif - } + } dl_ch0_ext+=6; rxF_ext+=6; @@ -4179,14 +4204,14 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, for (i=0; i<12; i++) { rxF_ext[i]=rxF[i]; #ifdef DEBUG_DLSCH_DEMOD - printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); + printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); #endif - } + } dl_ch0_ext+=12; rxF_ext+=12; } } else { - // printf("Extracting with pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half); + // printf("Extracting with pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half); j=0; if (skip_half==1) { @@ -4194,7 +4219,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, if (i!=((frame_parms->nushift+poffset)%6)) { rxF_ext[j]=rxF[i]; #ifdef DEBUG_DLSCH_DEMOD - printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j])); + printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j])); #endif dl_ch0_ext[j++]=dl_ch0[i]; } @@ -4207,7 +4232,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, if (i!=((frame_parms->nushift+poffset)%6)) { rxF_ext[j]=rxF[(i+6)]; #ifdef DEBUG_DLSCH_DEMOD - printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j])); + printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j])); #endif dl_ch0_ext[j++]=dl_ch0[i+6]; } @@ -4221,7 +4246,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF, (i!=((frame_parms->nushift+poffset+6)%12))) { rxF_ext[j]=rxF[i]; #ifdef DEBUG_DLSCH_DEMOD - printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j])); + printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j])); #endif dl_ch0_ext[j++]=dl_ch0[i]; } @@ -4253,7 +4278,7 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF, unsigned char subframe, uint32_t high_speed_flag, LTE_DL_FRAME_PARMS *frame_parms, - MIMO_mode_t mimo_mode) { + MIMO_mode_t mimo_mode) { int prb,nb_rb=0; int prb_off,prb_off2; @@ -4301,15 +4326,15 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF, skip_half=0; if (prb < 32) - rb_alloc_ind = (rb_alloc[0]>>prb) & 1; + rb_alloc_ind = (rb_alloc[0]>>prb) & 1; else if (prb < 64) - rb_alloc_ind = (rb_alloc[1]>>(prb-32)) & 1; + rb_alloc_ind = (rb_alloc[1]>>(prb-32)) & 1; else if (prb < 96) - rb_alloc_ind = (rb_alloc[2]>>(prb-64)) & 1; + rb_alloc_ind = (rb_alloc[2]>>(prb-64)) & 1; else if (prb < 100) - rb_alloc_ind = (rb_alloc[3]>>(prb-96)) & 1; + rb_alloc_ind = (rb_alloc[3]>>(prb-96)) & 1; else - rb_alloc_ind = 0; + rb_alloc_ind = 0; if (rb_alloc_ind == 1) nb_rb++; @@ -4317,73 +4342,73 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF, if ((frame_parms->N_RB_DL&1) == 0) { // even number of RBs - // PBCH - if ((subframe==0) && - (prb>=((frame_parms->N_RB_DL>>1)-3)) && - (prb<((frame_parms->N_RB_DL>>1)+3)) && - (l>=(nsymb>>1)) && - (l<((nsymb>>1) + 4))) { - rb_alloc_ind = 0; - // printf("symbol %d / rb %d: skipping PBCH REs\n",symbol,prb); - } - - //SSS - - if (((subframe==0)||(subframe==5)) && - (prb>=((frame_parms->N_RB_DL>>1)-3)) && - (prb<((frame_parms->N_RB_DL>>1)+3)) && - (l==sss_symb) ) { - rb_alloc_ind = 0; - // printf("symbol %d / rb %d: skipping SSS REs\n",symbol,prb); - } - - - - //PSS in subframe 0/5 if FDD - if (frame_parms->frame_type == FDD) { //FDD - if (((subframe==0)||(subframe==5)) && - (prb>=((frame_parms->N_RB_DL>>1)-3)) && - (prb<((frame_parms->N_RB_DL>>1)+3)) && - (l==pss_symb) ) { - rb_alloc_ind = 0; - // printf("symbol %d / rb %d: skipping PSS REs\n",symbol,prb); - } - } - - if ((frame_parms->frame_type == TDD) && - (subframe==6)) { //TDD Subframe 6 - if ((prb>=((frame_parms->N_RB_DL>>1)-3)) && - (prb<((frame_parms->N_RB_DL>>1)+3)) && - (l==pss_symb) ) { - rb_alloc_ind = 0; - } - } - - if (rb_alloc_ind==1) { // PRB is allocated - - - - prb_off = 12*prb; - prb_off2 = 1+(12*(prb-(frame_parms->N_RB_DL>>1))); - dl_ch0p = dl_ch0+(12*prb); - dl_ch1p = dl_ch1+(12*prb); - if (prb<(frame_parms->N_RB_DL>>1)){ - rxF = &rxdataF[aarx][prb_off+ - frame_parms->first_carrier_offset + - (symbol*(frame_parms->ofdm_symbol_size))]; - } - else { - rxF = &rxdataF[aarx][prb_off2+ - (symbol*(frame_parms->ofdm_symbol_size))]; - } - - /* - if (mimo_mode <= PUSCH_PRECODING1) + // PBCH + if ((subframe==0) && + (prb>=((frame_parms->N_RB_DL>>1)-3)) && + (prb<((frame_parms->N_RB_DL>>1)+3)) && + (l>=(nsymb>>1)) && + (l<((nsymb>>1) + 4))) { + rb_alloc_ind = 0; + // printf("symbol %d / rb %d: skipping PBCH REs\n",symbol,prb); + } + + //SSS + + if (((subframe==0)||(subframe==5)) && + (prb>=((frame_parms->N_RB_DL>>1)-3)) && + (prb<((frame_parms->N_RB_DL>>1)+3)) && + (l==sss_symb) ) { + rb_alloc_ind = 0; + // printf("symbol %d / rb %d: skipping SSS REs\n",symbol,prb); + } + + + + //PSS in subframe 0/5 if FDD + if (frame_parms->frame_type == FDD) { //FDD + if (((subframe==0)||(subframe==5)) && + (prb>=((frame_parms->N_RB_DL>>1)-3)) && + (prb<((frame_parms->N_RB_DL>>1)+3)) && + (l==pss_symb) ) { + rb_alloc_ind = 0; + // printf("symbol %d / rb %d: skipping PSS REs\n",symbol,prb); + } + } + + if ((frame_parms->frame_type == TDD) && + (subframe==6)) { //TDD Subframe 6 + if ((prb>=((frame_parms->N_RB_DL>>1)-3)) && + (prb<((frame_parms->N_RB_DL>>1)+3)) && + (l==pss_symb) ) { + rb_alloc_ind = 0; + } + } + + if (rb_alloc_ind==1) { // PRB is allocated + + + + prb_off = 12*prb; + prb_off2 = 1+(12*(prb-(frame_parms->N_RB_DL>>1))); + dl_ch0p = dl_ch0+(12*prb); + dl_ch1p = dl_ch1+(12*prb); + if (prb<(frame_parms->N_RB_DL>>1)){ + rxF = &rxdataF[aarx][prb_off+ + frame_parms->first_carrier_offset + + (symbol*(frame_parms->ofdm_symbol_size))]; + } + else { + rxF = &rxdataF[aarx][prb_off2+ + (symbol*(frame_parms->ofdm_symbol_size))]; + } + + /* + if (mimo_mode <= PUSCH_PRECODING1) *pmi_loc = (pmi>>((prb>>2)<<1))&3; - else - *pmi_loc=(pmi>>prb)&1;*/ + else + *pmi_loc=(pmi>>prb)&1;*/ - *pmi_loc = get_pmi(frame_parms->N_RB_DL,mimo_mode,pmi,prb); + *pmi_loc = get_pmi(frame_parms->N_RB_DL,mimo_mode,pmi,prb); pmi_loc++; @@ -4408,280 +4433,280 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF, dl_ch1_ext[j++]=dl_ch1p[i]; } } - dl_ch0_ext+=8; - dl_ch1_ext+=8; - rxF_ext+=8; + dl_ch0_ext+=8; + dl_ch1_ext+=8; + rxF_ext+=8; } // pilots==1 - } + } } else { // Odd number of RBs // PBCH - if ((subframe==0) && - (prb>((frame_parms->N_RB_DL>>1)-3)) && - (prb<((frame_parms->N_RB_DL>>1)+3)) && - (l>=(nsymb>>1)) && - (l<((nsymb>>1) + 4))) { - rb_alloc_ind = 0; - // printf("symbol %d / rb %d: skipping PBCH REs\n",symbol,prb); - } - - //SSS - - if (((subframe==0)||(subframe==5)) && - (prb>((frame_parms->N_RB_DL>>1)-3)) && - (prb<((frame_parms->N_RB_DL>>1)+3)) && - (l==sss_symb) ) { - rb_alloc_ind = 0; - // printf("symbol %d / rb %d: skipping SSS REs\n",symbol,prb); - } - - - - //PSS in subframe 0/5 if FDD - if (frame_parms->frame_type == FDD) { //FDD - if (((subframe==0)||(subframe==5)) && - (prb>((frame_parms->N_RB_DL>>1)-3)) && - (prb<((frame_parms->N_RB_DL>>1)+3)) && - (l==pss_symb) ) { - rb_alloc_ind = 0; - // printf("symbol %d / rb %d: skipping PSS REs\n",symbol,prb); - } - } - - if ((frame_parms->frame_type == TDD) && - ((subframe==1) || (subframe==6))) { //TDD Subframe 1-6 - if ((prb>((frame_parms->N_RB_DL>>1)-3)) && - (prb<((frame_parms->N_RB_DL>>1)+3)) && - (l==pss_symb) ) { - rb_alloc_ind = 0; - } - } - - if (rb_alloc_ind == 1) { - skip_half=0; - - //Check if we have to drop half a PRB due to PSS/SSS/PBCH - // skip_half == 0 means full PRB - // skip_half == 1 means first half is used (leftmost half-PRB from PSS/SSS/PBCH) - // skip_half == 2 means second half is used (rightmost half-PRB from PSS/SSS/PBCH) - //PBCH subframe 0, symbols nsymb>>1 ... nsymb>>1 + 3 - if ((subframe==0) && - (prb==((frame_parms->N_RB_DL>>1)-3)) && - (l>=(nsymb>>1)) && - (l<((nsymb>>1) + 4))) - skip_half=1; - else if ((subframe==0) && - (prb==((frame_parms->N_RB_DL>>1)+3)) && - (l>=(nsymb>>1)) && - (l<((nsymb>>1) + 4))) - skip_half=2; - - //SSS - if (((subframe==0)||(subframe==5)) && - (prb==((frame_parms->N_RB_DL>>1)-3)) && - (l==sss_symb)) - skip_half=1; - else if (((subframe==0)||(subframe==5)) && - (prb==((frame_parms->N_RB_DL>>1)+3)) && - (l==sss_symb)) - skip_half=2; - - //PSS Subframe 0,5 - if (((frame_parms->frame_type == FDD) && - (((subframe==0)||(subframe==5)))) || //FDD Subframes 0,5 - ((frame_parms->frame_type == TDD) && - (((subframe==1) || (subframe==6))))) { //TDD Subframes 1,6 - - if ((prb==((frame_parms->N_RB_DL>>1)-3)) && - (l==pss_symb)) - skip_half=1; - else if ((prb==((frame_parms->N_RB_DL>>1)+3)) && - (l==pss_symb)) - skip_half=2; - } - - - prb_off = 12*prb; - prb_off2 = 7+(12*(prb-(frame_parms->N_RB_DL>>1)-1)); - dl_ch0p = dl_ch0+(12*prb); - dl_ch1p = dl_ch1+(12*prb); - - if (prb<=(frame_parms->N_RB_DL>>1)){ - rxF = &rxdataF[aarx][prb_off+ - frame_parms->first_carrier_offset + - (symbol*(frame_parms->ofdm_symbol_size))]; - } - else { - rxF = &rxdataF[aarx][prb_off2+ - (symbol*(frame_parms->ofdm_symbol_size))]; - } + if ((subframe==0) && + (prb>((frame_parms->N_RB_DL>>1)-3)) && + (prb<((frame_parms->N_RB_DL>>1)+3)) && + (l>=(nsymb>>1)) && + (l<((nsymb>>1) + 4))) { + rb_alloc_ind = 0; + // printf("symbol %d / rb %d: skipping PBCH REs\n",symbol,prb); + } + + //SSS + + if (((subframe==0)||(subframe==5)) && + (prb>((frame_parms->N_RB_DL>>1)-3)) && + (prb<((frame_parms->N_RB_DL>>1)+3)) && + (l==sss_symb) ) { + rb_alloc_ind = 0; + // printf("symbol %d / rb %d: skipping SSS REs\n",symbol,prb); + } + + + + //PSS in subframe 0/5 if FDD + if (frame_parms->frame_type == FDD) { //FDD + if (((subframe==0)||(subframe==5)) && + (prb>((frame_parms->N_RB_DL>>1)-3)) && + (prb<((frame_parms->N_RB_DL>>1)+3)) && + (l==pss_symb) ) { + rb_alloc_ind = 0; + // printf("symbol %d / rb %d: skipping PSS REs\n",symbol,prb); + } + } + + if ((frame_parms->frame_type == TDD) && + ((subframe==1) || (subframe==6))) { //TDD Subframe 1-6 + if ((prb>((frame_parms->N_RB_DL>>1)-3)) && + (prb<((frame_parms->N_RB_DL>>1)+3)) && + (l==pss_symb) ) { + rb_alloc_ind = 0; + } + } + + if (rb_alloc_ind == 1) { + skip_half=0; + + //Check if we have to drop half a PRB due to PSS/SSS/PBCH + // skip_half == 0 means full PRB + // skip_half == 1 means first half is used (leftmost half-PRB from PSS/SSS/PBCH) + // skip_half == 2 means second half is used (rightmost half-PRB from PSS/SSS/PBCH) + //PBCH subframe 0, symbols nsymb>>1 ... nsymb>>1 + 3 + if ((subframe==0) && + (prb==((frame_parms->N_RB_DL>>1)-3)) && + (l>=(nsymb>>1)) && + (l<((nsymb>>1) + 4))) + skip_half=1; + else if ((subframe==0) && + (prb==((frame_parms->N_RB_DL>>1)+3)) && + (l>=(nsymb>>1)) && + (l<((nsymb>>1) + 4))) + skip_half=2; + + //SSS + if (((subframe==0)||(subframe==5)) && + (prb==((frame_parms->N_RB_DL>>1)-3)) && + (l==sss_symb)) + skip_half=1; + else if (((subframe==0)||(subframe==5)) && + (prb==((frame_parms->N_RB_DL>>1)+3)) && + (l==sss_symb)) + skip_half=2; + + //PSS Subframe 0,5 + if (((frame_parms->frame_type == FDD) && + (((subframe==0)||(subframe==5)))) || //FDD Subframes 0,5 + ((frame_parms->frame_type == TDD) && + (((subframe==1) || (subframe==6))))) { //TDD Subframes 1,6 + + if ((prb==((frame_parms->N_RB_DL>>1)-3)) && + (l==pss_symb)) + skip_half=1; + else if ((prb==((frame_parms->N_RB_DL>>1)+3)) && + (l==pss_symb)) + skip_half=2; + } + + + prb_off = 12*prb; + prb_off2 = 7+(12*(prb-(frame_parms->N_RB_DL>>1)-1)); + dl_ch0p = dl_ch0+(12*prb); + dl_ch1p = dl_ch1+(12*prb); + + if (prb<=(frame_parms->N_RB_DL>>1)){ + rxF = &rxdataF[aarx][prb_off+ + frame_parms->first_carrier_offset + + (symbol*(frame_parms->ofdm_symbol_size))]; + } + else { + rxF = &rxdataF[aarx][prb_off2+ + (symbol*(frame_parms->ofdm_symbol_size))]; + } #ifdef DEBUG_DLSCH_DEMOD - printf("symbol %d / rb %d: alloc %d skip_half %d (rxF %p, rxF_ext %p) prb_off (%d,%d)\n",symbol,prb,rb_alloc_ind,skip_half,rxF,rxF_ext,prb_off,prb_off2); + printf("symbol %d / rb %d: alloc %d skip_half %d (rxF %p, rxF_ext %p) prb_off (%d,%d)\n",symbol,prb,rb_alloc_ind,skip_half,rxF,rxF_ext,prb_off,prb_off2); #endif /* if (mimo_mode <= PUSCH_PRECODING1) *pmi_loc = (pmi>>((prb>>2)<<1))&3; - else - *pmi_loc=(pmi>>prb)&1; + else + *pmi_loc=(pmi>>prb)&1; // printf("symbol_mod %d (pilots %d) rb %d, sb %d, pmi %d (pmi_loc %p,rxF %p, ch00 %p, ch01 %p, rxF_ext %p dl_ch0_ext %p dl_ch1_ext %p)\n",symbol_mod,pilots,prb,prb>>2,*pmi_loc,pmi_loc,rxF,dl_ch0, dl_ch1, rxF_ext,dl_ch0_ext,dl_ch1_ext); */ - *pmi_loc = get_pmi(frame_parms->N_RB_DL,mimo_mode,pmi,prb); + *pmi_loc = get_pmi(frame_parms->N_RB_DL,mimo_mode,pmi,prb); pmi_loc++; - if (prb != (frame_parms->N_RB_DL>>1)) { // This PRB is not around DC - if (pilots==0) { - if (skip_half==1) { - memcpy(dl_ch0_ext,dl_ch0p,6*sizeof(int32_t)); - memcpy(dl_ch1_ext,dl_ch1p,6*sizeof(int32_t)); - memcpy(rxF_ext,rxF,6*sizeof(int32_t)); + if (prb != (frame_parms->N_RB_DL>>1)) { // This PRB is not around DC + if (pilots==0) { + if (skip_half==1) { + memcpy(dl_ch0_ext,dl_ch0p,6*sizeof(int32_t)); + memcpy(dl_ch1_ext,dl_ch1p,6*sizeof(int32_t)); + memcpy(rxF_ext,rxF,6*sizeof(int32_t)); #ifdef DEBUG_DLSCH_DEMOD - for (i=0;i<6;i++) - printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); + for (i=0;i<6;i++) + printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); #endif - dl_ch0_ext+=6; - dl_ch1_ext+=6; - rxF_ext+=6; - } else if (skip_half==2) { - memcpy(dl_ch0_ext,dl_ch0p+6,6*sizeof(int32_t)); - memcpy(dl_ch1_ext,dl_ch1p+6,6*sizeof(int32_t)); - memcpy(rxF_ext,rxF+6,6*sizeof(int32_t)); + dl_ch0_ext+=6; + dl_ch1_ext+=6; + rxF_ext+=6; + } else if (skip_half==2) { + memcpy(dl_ch0_ext,dl_ch0p+6,6*sizeof(int32_t)); + memcpy(dl_ch1_ext,dl_ch1p+6,6*sizeof(int32_t)); + memcpy(rxF_ext,rxF+6,6*sizeof(int32_t)); #ifdef DEBUG_DLSCH_DEMOD - for (i=0;i<6;i++) - printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); + for (i=0;i<6;i++) + printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); #endif - dl_ch0_ext+=6; - dl_ch1_ext+=6; - rxF_ext+=6; - } else { // skip_half==0 - memcpy(dl_ch0_ext,dl_ch0p,12*sizeof(int32_t)); - memcpy(dl_ch1_ext,dl_ch1p,12*sizeof(int32_t)); - memcpy(rxF_ext,rxF,12*sizeof(int32_t)); + dl_ch0_ext+=6; + dl_ch1_ext+=6; + rxF_ext+=6; + } else { // skip_half==0 + memcpy(dl_ch0_ext,dl_ch0p,12*sizeof(int32_t)); + memcpy(dl_ch1_ext,dl_ch1p,12*sizeof(int32_t)); + memcpy(rxF_ext,rxF,12*sizeof(int32_t)); #ifdef DEBUG_DLSCH_DEMOD - for (i=0;i<12;i++) - printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); + for (i=0;i<12;i++) + printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); #endif - dl_ch0_ext+=12; - dl_ch1_ext+=12; - rxF_ext+=12; - } - } else { // pilots=1 - j=0; - - if (skip_half==1) { - for (i=0; i<6; i++) { - if ((i!=frame_parms->nushift) && - (i!=((frame_parms->nushift+3)%6))) { - rxF_ext[j]=rxF[i]; + dl_ch0_ext+=12; + dl_ch1_ext+=12; + rxF_ext+=12; + } + } else { // pilots=1 + j=0; + + if (skip_half==1) { + for (i=0; i<6; i++) { + if ((i!=frame_parms->nushift) && + (i!=((frame_parms->nushift+3)%6))) { + rxF_ext[j]=rxF[i]; #ifdef DEBUG_DLSCH_DEMOD - printf("(pilots,skip1)extract rb %d, re %d (%d)=> (%d,%d)\n",prb,i,j,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j])); + printf("(pilots,skip1)extract rb %d, re %d (%d)=> (%d,%d)\n",prb,i,j,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j])); #endif - dl_ch0_ext[j]=dl_ch0p[i]; - dl_ch1_ext[j++]=dl_ch1p[i]; - } - } - dl_ch0_ext+=4; - dl_ch1_ext+=4; - rxF_ext+=4; - } else if (skip_half==2) { - for (i=0; i<6; i++) { - if ((i!=frame_parms->nushift) && - (i!=((frame_parms->nushift+3)%6))) { - rxF_ext[j]=rxF[(i+6)]; + dl_ch0_ext[j]=dl_ch0p[i]; + dl_ch1_ext[j++]=dl_ch1p[i]; + } + } + dl_ch0_ext+=4; + dl_ch1_ext+=4; + rxF_ext+=4; + } else if (skip_half==2) { + for (i=0; i<6; i++) { + if ((i!=frame_parms->nushift) && + (i!=((frame_parms->nushift+3)%6))) { + rxF_ext[j]=rxF[(i+6)]; #ifdef DEBUG_DLSCH_DEMOD - printf("(pilots,skip2)extract rb %d, re %d (%d) => (%d,%d)\n",prb,i,j,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j])); + printf("(pilots,skip2)extract rb %d, re %d (%d) => (%d,%d)\n",prb,i,j,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j])); #endif - dl_ch0_ext[j]=dl_ch0p[i+6]; - dl_ch1_ext[j++]=dl_ch1p[i+6]; - } - } - dl_ch0_ext+=4; - dl_ch1_ext+=4; - rxF_ext+=4; - - } else { //skip_half==0 - for (i=0; i<12; i++) { - if ((i!=frame_parms->nushift) && - (i!=frame_parms->nushift+3) && - (i!=frame_parms->nushift+6) && - (i!=((frame_parms->nushift+9)%12))) { - rxF_ext[j]=rxF[i]; + dl_ch0_ext[j]=dl_ch0p[i+6]; + dl_ch1_ext[j++]=dl_ch1p[i+6]; + } + } + dl_ch0_ext+=4; + dl_ch1_ext+=4; + rxF_ext+=4; + + } else { //skip_half==0 + for (i=0; i<12; i++) { + if ((i!=frame_parms->nushift) && + (i!=frame_parms->nushift+3) && + (i!=frame_parms->nushift+6) && + (i!=((frame_parms->nushift+9)%12))) { + rxF_ext[j]=rxF[i]; #ifdef DEBUG_DLSCH_DEMOD - printf("(pilots)extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j])); + printf("(pilots)extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j])); #endif - dl_ch0_ext[j] =dl_ch0p[i]; - dl_ch1_ext[j++]=dl_ch1p[i]; - } - } - dl_ch0_ext+=8; - dl_ch1_ext+=8; - rxF_ext+=8; - } //skip_half==0 - } //pilots==1 - } else { // Do middle RB (around DC) - - if (pilots==0) { - memcpy(dl_ch0_ext,dl_ch0p,6*sizeof(int32_t)); - memcpy(dl_ch1_ext,dl_ch1p,6*sizeof(int32_t)); - memcpy(rxF_ext,rxF,6*sizeof(int32_t)); + dl_ch0_ext[j] =dl_ch0p[i]; + dl_ch1_ext[j++]=dl_ch1p[i]; + } + } + dl_ch0_ext+=8; + dl_ch1_ext+=8; + rxF_ext+=8; + } //skip_half==0 + } //pilots==1 + } else { // Do middle RB (around DC) + + if (pilots==0) { + memcpy(dl_ch0_ext,dl_ch0p,6*sizeof(int32_t)); + memcpy(dl_ch1_ext,dl_ch1p,6*sizeof(int32_t)); + memcpy(rxF_ext,rxF,6*sizeof(int32_t)); #ifdef DEBUG_DLSCH_DEMOD - for (i=0; i<6; i++) { - printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); - } + for (i=0; i<6; i++) { + printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); + } #endif - rxF_ext+=6; - dl_ch0_ext+=6; - dl_ch1_ext+=6; - dl_ch0p+=6; - dl_ch1p+=6; + rxF_ext+=6; + dl_ch0_ext+=6; + dl_ch1_ext+=6; + dl_ch0p+=6; + dl_ch1p+=6; - rxF = &rxdataF[aarx][1+((symbol*(frame_parms->ofdm_symbol_size)))]; + rxF = &rxdataF[aarx][1+((symbol*(frame_parms->ofdm_symbol_size)))]; - memcpy(dl_ch0_ext,dl_ch0p,6*sizeof(int32_t)); - memcpy(dl_ch1_ext,dl_ch1p,6*sizeof(int32_t)); - memcpy(rxF_ext,rxF,6*sizeof(int32_t)); + memcpy(dl_ch0_ext,dl_ch0p,6*sizeof(int32_t)); + memcpy(dl_ch1_ext,dl_ch1p,6*sizeof(int32_t)); + memcpy(rxF_ext,rxF,6*sizeof(int32_t)); #ifdef DEBUG_DLSCH_DEMOD - for (i=0; i<6; i++) { - printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); - } + for (i=0; i<6; i++) { + printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i])); + } #endif - rxF_ext+=6; - dl_ch0_ext+=6; - dl_ch1_ext+=6; - } else { // pilots==1 - j=0; - - for (i=0; i<6; i++) { - if ((i!=frame_parms->nushift) && - (i!=((frame_parms->nushift+3)%6))) { - dl_ch0_ext[j]=dl_ch0p[i]; - dl_ch1_ext[j]=dl_ch1p[i]; - rxF_ext[j++]=rxF[i]; + rxF_ext+=6; + dl_ch0_ext+=6; + dl_ch1_ext+=6; + } else { // pilots==1 + j=0; + + for (i=0; i<6; i++) { + if ((i!=frame_parms->nushift) && + (i!=((frame_parms->nushift+3)%6))) { + dl_ch0_ext[j]=dl_ch0p[i]; + dl_ch1_ext[j]=dl_ch1p[i]; + rxF_ext[j++]=rxF[i]; #ifdef DEBUG_DLSCH_DEMOD - printf("(pilots)extract rb %d, re %d (%d) => (%d,%d)\n",prb,i,j,*(short *)&rxF[i],*(1+(short*)&rxF[i])); + printf("(pilots)extract rb %d, re %d (%d) => (%d,%d)\n",prb,i,j,*(short *)&rxF[i],*(1+(short*)&rxF[i])); #endif - } - } - rxF = &rxdataF[aarx][1+symbol*(frame_parms->ofdm_symbol_size)]; - - for (; i<12; i++) { - if ((i!=((frame_parms->nushift+6)%12)) && - (i!=((frame_parms->nushift+9)%12))) { - dl_ch0_ext[j]=dl_ch0p[i]; - dl_ch1_ext[j]=dl_ch1p[i]; - rxF_ext[j++]=rxF[i-6]; + } + } + rxF = &rxdataF[aarx][1+symbol*(frame_parms->ofdm_symbol_size)]; + + for (; i<12; i++) { + if ((i!=((frame_parms->nushift+6)%12)) && + (i!=((frame_parms->nushift+9)%12))) { + dl_ch0_ext[j]=dl_ch0p[i]; + dl_ch1_ext[j]=dl_ch1p[i]; + rxF_ext[j++]=rxF[i-6]; #ifdef DEBUG_DLSCH_DEMOD - printf("(pilots)extract rb %d, re %d (%d) => (%d,%d)\n",prb,i,j,*(short *)&rxF[1+i-6],*(1+(short*)&rxF[1+i-6])); + printf("(pilots)extract rb %d, re %d (%d) => (%d,%d)\n",prb,i,j,*(short *)&rxF[1+i-6],*(1+(short*)&rxF[1+i-6])); #endif - } - } - - dl_ch0_ext+=8; - dl_ch1_ext+=8; - rxF_ext+=8; - } //pilots==1 - } // if Middle PRB - } // if odd PRB + } + } + + dl_ch0_ext+=8; + dl_ch1_ext+=8; + rxF_ext+=8; + } //pilots==1 + } // if Middle PRB + } // if odd PRB } // if rballoc==1 } // for prb } // for aarx @@ -4784,7 +4809,7 @@ void print_bytes(char *s,__m128i *x) printf("%s : %d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n",s, tempb[0],tempb[1],tempb[2],tempb[3],tempb[4],tempb[5],tempb[6],tempb[7], tempb[8],tempb[9],tempb[10],tempb[11],tempb[12],tempb[13],tempb[14],tempb[15] - ); + ); } diff --git a/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c b/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c index 4c70f0823075cad3ccc7e81faf56013cc99ee08e..04353aa663ee35e490dfc3da52809623c9d793cf 100644 --- a/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c +++ b/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c @@ -156,7 +156,7 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms, uint8_t *x0 = NULL; //dlsch0_harq->e; - MIMO_mode_t mimo_mode = dlsch0_harq->mimo_mode; + MIMO_mode_t mimo_mode;//= dlsch0_harq->mimo_mode; int first_layer0; //= dlsch0_harq->first_layer; int Nlayers0; // = dlsch0_harq->Nlayers; @@ -1411,8 +1411,13 @@ int dlsch_modulation(int32_t **txdataF, nsymb = (frame_parms->Ncp==0) ? 14:12; + if (dlsch0 != NULL){ amp_rho_a = (int16_t)(((int32_t)amp*dlsch0->sqrt_rho_a)>>13); //amp=512 in full scale; dlsch0->sqrt_rho_a=8192in Q2.13, 1 in full scale amp_rho_b = (int16_t)(((int32_t)amp*dlsch0->sqrt_rho_b)>>13); + } else{ + amp_rho_a = (int16_t)(((int32_t)amp*dlsch1->sqrt_rho_a)>>13); + amp_rho_b = (int16_t)(((int32_t)amp*dlsch1->sqrt_rho_b)>>13); + } if (mod_order0 == 4) for (i=0; i<4; i++) { @@ -1445,6 +1450,7 @@ int dlsch_modulation(int32_t **txdataF, // printf("num_pdcch_symbols %d, nsymb %d\n",num_pdcch_symbols,nsymb); for (l=num_pdcch_symbols; l<nsymb; l++) { + if (dlsch0 != NULL ) { #ifdef DEBUG_DLSCH_MODULATION printf("Generating DLSCH (harq_pid %d,mimo %d, pmi_alloc0 %lx, mod0 %d, mod1 %d, rb_alloc[0] %d) in %d\n", harq_pid, @@ -1455,6 +1461,7 @@ int dlsch_modulation(int32_t **txdataF, rb_alloc[0], len); #endif + } if (frame_parms->Ncp==0) { // normal prefix if ((l==4)||(l==11)) @@ -1611,9 +1618,11 @@ int dlsch_modulation(int32_t **txdataF, } } - if (dlsch0_harq->Nlayers>1) { - msg("Nlayers %d: re_offset %d, symbol %d offset %d\n",dlsch0_harq->Nlayers,re_offset,l,symbol_offset); - return(-1); + if (dlsch0) { + if (dlsch0_harq->Nlayers>1) { + msg("Nlayers %d: re_offset %d, symbol %d offset %d\n",dlsch0_harq->Nlayers,re_offset,l,symbol_offset); + return(-1); + } } if (dlsch1) { @@ -1639,6 +1648,17 @@ int dlsch_modulation(int32_t **txdataF, if (rb_alloc_ind > 0) { // printf("Allocated rb %d/symbol %d, skip_half %d, subframe_offset %d, symbol_offset %d, re_offset %d, jj %d\n",rb,l,skip_half,subframe_offset,symbol_offset,re_offset,jj); + if (dlsch0 != NULL) { + get_pmi_temp = get_pmi(frame_parms->N_RB_DL, + dlsch0->harq_processes[harq_pid]->mimo_mode, + dlsch0->harq_processes[harq_pid]->pmi_alloc, + rb); + } else + get_pmi_temp = get_pmi(frame_parms->N_RB_DL, + dlsch1->harq_processes[harq_pid]->mimo_mode, + dlsch1->harq_processes[harq_pid]->pmi_alloc, + rb); + allocate_REs_in_RB(frame_parms, txdataF, @@ -1646,11 +1666,11 @@ int dlsch_modulation(int32_t **txdataF, &jj2, re_offset, symbol_offset, - dlsch0->harq_processes[harq_pid], - (dlsch1==NULL) ? NULL : dlsch1->harq_processes[harq_pid], + (dlsch0 == NULL) ? NULL : dlsch0->harq_processes[harq_pid], + (dlsch1 == NULL) ? NULL : dlsch1->harq_processes[harq_pid], pilots, ((pilots) ? amp_rho_b : amp_rho_a), - get_pmi(frame_parms->N_RB_DL,dlsch0->harq_processes[harq_pid]->mimo_mode,dlsch0->harq_processes[harq_pid]->pmi_alloc,rb), + get_pmi_temp, qam_table_s0, qam_table_s1, &re_allocated, @@ -1672,7 +1692,11 @@ int dlsch_modulation(int32_t **txdataF, } #ifdef DEBUG_DLSCH_MODULATION - msg("generate_dlsch : jj = %d,re_allocated = %d (G %d)\n",jj,re_allocated,get_G(frame_parms,dlsch0_harq->nb_rb,dlsch0_harq->rb_alloc,mod_order0,Nl0,2,0,subframe_offset)); + if (dlsch0 != NULL){ + msg("generate_dlsch : jj = %d,re_allocated = %d (G %d)\n",jj,re_allocated,get_G(frame_parms,dlsch0_harq->nb_rb,dlsch0_harq->rb_alloc,mod_order0,Nl0,2,0,subframe_offset)); + }else{ + msg("generate_dlsch : jj = %d,re_allocated = %d (G %d)\n",jj,re_allocated,get_G(frame_parms,dlsch1_harq->nb_rb,dlsch1_harq->rb_alloc,mod_order1,Nl1,2,0,subframe_offset)); + } #endif VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_MODULATION, VCD_FUNCTION_OUT); diff --git a/openair1/PHY/LTE_TRANSPORT/power_control.c b/openair1/PHY/LTE_TRANSPORT/power_control.c index f811f7524bb74c9153e288e5122bab114c585141..bd6b6387f1906dfa0c3c0b25fa2a1029bb9759b2 100644 --- a/openair1/PHY/LTE_TRANSPORT/power_control.c +++ b/openair1/PHY/LTE_TRANSPORT/power_control.c @@ -34,9 +34,9 @@ double ratioPB[2][4]={{ 1.0,4.0/5.0,3.0/5.0,2.0/5.0}, { 5.0/4.0,1.0,3.0/4.0,1.0/2.0}}; */ - + double ratioPB[2][4]={{ 0.00000, -0.96910, -2.21849, -3.97940}, //in db - { 0.96910, 0.00000, -1.24939, -3.01030}}; + { 0.96910, 0.00000, -1.24939, -3.01030}}; double pa_values[8]={-6.0,-4.77,-3.0,-1.77,0.0,1.0,2.0,3.0}; //reported by higher layers @@ -45,21 +45,21 @@ double get_pa_dB(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated) return(pa_values[pdsch_config_dedicated->p_a]); } -double computeRhoA_eNB(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated, - LTE_eNB_DLSCH_t *dlsch_eNB,int dl_power_off, uint8_t n_antenna_port){ +double computeRhoA_eNB(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated, + LTE_eNB_DLSCH_t *dlsch_eNB, int dl_power_off, uint8_t n_antenna_port){ double rho_a_dB; double sqrt_rho_a_lin; rho_a_dB = pa_values[ pdsch_config_dedicated->p_a]; - + if(!dl_power_off) //if dl_power_offset is 0, this is for MU-interference, TM5 rho_a_dB-=10*log10(2); - + if(n_antenna_port==4) // see TS 36.213 Section 5.2 rho_a_dB=+10*log10(2); - - sqrt_rho_a_lin= pow(10,(0.05*rho_a_dB)); - + + sqrt_rho_a_lin= pow(10,(0.05*rho_a_dB)); + dlsch_eNB->sqrt_rho_a= (short) (sqrt_rho_a_lin*pow(2,13)); #if DEBUG_PC @@ -78,9 +78,9 @@ double computeRhoB_eNB(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated, double rho_a_dB, rho_b_dB; double sqrt_rho_b_lin; - + rho_a_dB= computeRhoA_eNB(pdsch_config_dedicated,dlsch_eNB,dl_power_off, n_antenna_port); - + if(n_antenna_port>1) rho_b_dB= ratioPB[1][pdsch_config_common->p_b] + rho_a_dB; else @@ -99,24 +99,24 @@ double computeRhoB_eNB(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated, double computeRhoA_UE(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated, LTE_UE_DLSCH_t *dlsch_ue, - unsigned char dl_power_off, - uint8_t n_antenna_port - ){ - + unsigned char dl_power_off, + uint8_t n_antenna_port + ){ + double rho_a_dB; double sqrt_rho_a_lin; rho_a_dB = pa_values[ pdsch_config_dedicated->p_a]; - - if(!dl_power_off) - rho_a_dB-=10*log10(2); + + if(!dl_power_off) + rho_a_dB-=10*log10(2); //if dl_power_offset is 0, this is for MU-interference, TM5. But in practice UE may assume 16 or 64QAM TM4 as multiuser - + if(n_antenna_port==4) // see TS 36.213 Section 5.2 rho_a_dB=+10*log10(2); - - sqrt_rho_a_lin= pow(10,(0.05*rho_a_dB)); - + + sqrt_rho_a_lin= pow(10,(0.05*rho_a_dB)); + dlsch_ue->sqrt_rho_a= (short) (sqrt_rho_a_lin*pow(2,13)); #ifdef DEBUG_PC @@ -135,9 +135,9 @@ double computeRhoB_UE(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated, double rho_a_dB, rho_b_dB; double sqrt_rho_b_lin; - + rho_a_dB= computeRhoA_UE(pdsch_config_dedicated,dlsch_ue,dl_power_off, n_antenna_port); - + if(n_antenna_port>1) rho_b_dB= ratioPB[1][pdsch_config_common->p_b] + rho_a_dB; else diff --git a/openair1/PHY/LTE_TRANSPORT/proto.h b/openair1/PHY/LTE_TRANSPORT/proto.h index 6a889c5dfb9f87dbc37715db4f1921bb849ebcc3..b4874569ae96282332fc6f9720d68514fdab1521 100644 --- a/openair1/PHY/LTE_TRANSPORT/proto.h +++ b/openair1/PHY/LTE_TRANSPORT/proto.h @@ -217,7 +217,7 @@ int32_t dlsch_modulation_SIC(int32_t **sic_buffer, uint8_t num_pdcch_symbols, LTE_eNB_DLSCH_t *dlsch0, LTE_eNB_DLSCH_t *dlsch1, - int G); + int G); /* \brief This function is the top-level routine for generation of the sub-frame signal (frequency-domain) for MCH. @param txdataF Table of pointers for frequency-domain TX signals @@ -720,15 +720,15 @@ int32_t dlsch_qpsk_llr(LTE_DL_FRAME_PARMS *frame_parms, int32_t dlsch_qpsk_llr_SIC(LTE_DL_FRAME_PARMS *frame_parms, int **rxdataF_comp, - int32_t **sic_buffer, - int **rho_i, + int32_t **sic_buffer, + int **rho_i, short *dlsch_llr, - uint8_t num_pdcch_symbols, + uint8_t num_pdcch_symbols, uint16_t nb_rb, uint8_t subframe, - uint32_t rb_alloc, + uint32_t rb_alloc, uint16_t mod_order_0, - LTE_UE_DLSCH_t *dlsch0); + LTE_UE_DLSCH_t *dlsch0); void dlsch_16qam_llr(LTE_DL_FRAME_PARMS *frame_parms, int32_t **rxdataF_comp, @@ -753,30 +753,30 @@ void dlsch_16qam_llr(LTE_DL_FRAME_PARMS *frame_parms, */ void dlsch_16qam_llr_SIC (LTE_DL_FRAME_PARMS *frame_parms, int32_t **rxdataF_comp, - int32_t **sic_buffer, //Q15 - int32_t **rho_i, - int16_t *dlsch_llr, - uint8_t num_pdcch_symbols, - int32_t **dl_ch_mag, - uint16_t nb_rb, - uint8_t subframe, - uint32_t rb_alloc, + int32_t **sic_buffer, //Q15 + int32_t **rho_i, + int16_t *dlsch_llr, + uint8_t num_pdcch_symbols, + int32_t **dl_ch_mag, + uint16_t nb_rb, + uint8_t subframe, + uint32_t rb_alloc, uint16_t mod_order_0, - LTE_UE_DLSCH_t *dlsch0); + LTE_UE_DLSCH_t *dlsch0); void dlsch_64qam_llr_SIC(LTE_DL_FRAME_PARMS *frame_parms, int32_t **rxdataF_comp, - int32_t **sic_buffer, //Q15 - int32_t **rho_i, - int16_t *dlsch_llr, - uint8_t num_pdcch_symbols, - int32_t **dl_ch_mag, - int32_t **dl_ch_magb, - uint16_t nb_rb, - uint8_t subframe, - uint32_t rb_alloc, + int32_t **sic_buffer, //Q15 + int32_t **rho_i, + int16_t *dlsch_llr, + uint8_t num_pdcch_symbols, + int32_t **dl_ch_mag, + int32_t **dl_ch_magb, + uint16_t nb_rb, + uint8_t subframe, + uint32_t rb_alloc, uint16_t mod_order_0, - LTE_UE_DLSCH_t *dlsch0); + LTE_UE_DLSCH_t *dlsch0); void dlsch_64qam_llr(LTE_DL_FRAME_PARMS *frame_parms, @@ -889,12 +889,12 @@ void dlsch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms, uint8_t dual_stream_UE); void dlsch_detection_mrc_TM34(LTE_DL_FRAME_PARMS *frame_parms, - LTE_UE_PDSCH *lte_ue_pdsch_vars, - int harq_pid, - int round, - unsigned char symbol, - unsigned short nb_rb, - unsigned char dual_stream_UE); + LTE_UE_PDSCH *lte_ue_pdsch_vars, + int harq_pid, + int round, + unsigned char symbol, + unsigned short nb_rb, + unsigned char dual_stream_UE); /** \fn dlsch_extract_rbs_single(int32_t **rxdataF, int32_t **dl_ch_estimates, @@ -966,8 +966,8 @@ uint16_t dlsch_extract_rbs_dual(int32_t **rxdataF, uint8_t symbol, uint8_t subframe, uint32_t high_speed_flag, - LTE_DL_FRAME_PARMS *frame_parms, - MIMO_mode_t mimo_mode); + LTE_DL_FRAME_PARMS *frame_parms, + MIMO_mode_t mimo_mode); /** \brief This function performs channel compensation (matched filtering) on the received RBs for this allocation. In addition, it computes the squared-magnitude of the channel with weightings for 16QAM/64QAM detection as well as dual-stream detection (cross-correlation) @param rxdataF_ext Frequency-domain received signal in RBs to be demodulated @@ -1013,7 +1013,7 @@ void dlsch_dual_stream_correlationTM34(LTE_DL_FRAME_PARMS *frame_parms, int **dl_ch_estimates_ext_i, int **dl_ch_rho_ext, unsigned char output_shift0, - unsigned char output_shift1); + unsigned char output_shift1); void dlsch_channel_compensation_TM56(int **rxdataF_ext, int **dl_ch_estimates_ext, @@ -1032,18 +1032,18 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext, void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms, - LTE_UE_PDSCH *lte_ue_pdsch_vars, - PHY_MEASUREMENTS *phy_measurements, - int eNB_id, - unsigned char symbol, - unsigned char mod_order0, - unsigned char mod_order1, - int harq_pid, - int round, - MIMO_mode_t mimo_mode, - unsigned short nb_rb, - unsigned char output_shift0, - unsigned char output_shift1); + LTE_UE_PDSCH *lte_ue_pdsch_vars, + PHY_MEASUREMENTS *phy_measurements, + int eNB_id, + unsigned char symbol, + unsigned char mod_order0, + unsigned char mod_order1, + int harq_pid, + int round, + MIMO_mode_t mimo_mode, + unsigned short nb_rb, + unsigned char output_shift0, + unsigned char output_shift1); /** \brief This function computes the average channel level over all allocated RBs and antennas (TX/RX) in order to compute output shift for compensated signal @@ -1061,13 +1061,13 @@ void dlsch_channel_level(int32_t **dl_ch_estimates_ext, void dlsch_channel_level_TM34(int **dl_ch_estimates_ext, - LTE_DL_FRAME_PARMS *frame_parms, - unsigned char *pmi_ext, - int *avg_0, - int *avg_1, - uint8_t symbol, - unsigned short nb_rb, - MIMO_mode_t mimo_mode); + LTE_DL_FRAME_PARMS *frame_parms, + unsigned char *pmi_ext, + int *avg_0, + int *avg_1, + uint8_t symbol, + unsigned short nb_rb, + MIMO_mode_t mimo_mode); void dlsch_channel_level_TM56(int32_t **dl_ch_estimates_ext, @@ -1121,7 +1121,7 @@ uint32_t dlsch_decoding_emul(PHY_VARS_UE *phy_vars_ue, - RE extraction (pilot, PBCH, synch. signals) - antenna combining (MRC, Alamouti, cycling) - LLR computation - This function supports TM1, 2, 3, 5, and 6. + This function supports TM1, 2, 3, 5, and 6. @param phy_vars_ue Pointer to PHY variables @param type Type of PDSCH (SI_PDSCH,RA_PDSCH,PDSCH,PMCH) @param eNB_id eNb index (Nid1) 0,1,2 @@ -1129,19 +1129,19 @@ uint32_t dlsch_decoding_emul(PHY_VARS_UE *phy_vars_ue, @param subframe Subframe number @param symbol Symbol on which to act (within sub-frame) @param first_symbol_flag set to 1 on first DLSCH symbol - @param rx_type. rx_type=RX_IC_single_stream will enable interference cancellation of a second stream when decoding the first stream. In case of TM1, 2, 5, and this can cancel interference from a neighbouring cell given by eNB_id_i. In case of TM5, eNB_id_i should be set to n_connected_eNB to perform multi-user interference cancellation. In case of TM3, eNB_id_i should be set to eNB_id to perform co-channel interference cancellation; this option should be used together with an interference cancellation step [...]. In case of TM3, if rx_type=RX_IC_dual_stream, both streams will be decoded by applying the IC single stream receiver twice. + @param rx_type. rx_type=RX_IC_single_stream will enable interference cancellation of a second stream when decoding the first stream. In case of TM1, 2, 5, and this can cancel interference from a neighbouring cell given by eNB_id_i. In case of TM5, eNB_id_i should be set to n_connected_eNB to perform multi-user interference cancellation. In case of TM3, eNB_id_i should be set to eNB_id to perform co-channel interference cancellation; this option should be used together with an interference cancellation step [...]. In case of TM3, if rx_type=RX_IC_dual_stream, both streams will be decoded by applying the IC single stream receiver twice. @param i_mod Modulation order of the interfering stream */ int32_t rx_pdsch(PHY_VARS_UE *phy_vars_ue, - PDSCH_t type, - uint8_t eNB_id, - uint8_t eNB_id_i, - uint8_t subframe, - uint8_t symbol, - uint8_t first_symbol_flag, - RX_type_t rx_type, - uint8_t i_mod, - uint8_t harq_pid); + PDSCH_t type, + uint8_t eNB_id, + uint8_t eNB_id_i, + uint8_t subframe, + uint8_t symbol, + uint8_t first_symbol_flag, + RX_type_t rx_type, + uint8_t i_mod, + uint8_t harq_pid); int32_t rx_pdcch(LTE_UE_COMMON *lte_ue_common_vars, LTE_UE_PDCCH **lte_ue_pdcch_vars, @@ -1322,7 +1322,7 @@ uint32_t get_TBS_UL(uint8_t mcs, uint16_t nb_rb); */ uint32_t get_prb(int N_RB_DL,int odd_slot,int vrb,int Ngap); -/* \brief Return prb for a given vrb index +/* \brief Return prb for a given vrb index @param vrb_type VRB type (0=localized,1=distributed) @param rb_alloc_dci rballoc field from DCI */ @@ -1437,7 +1437,7 @@ uint8_t subframe2harq_pid(LTE_DL_FRAME_PARMS *frame_parms,frame_t frame,uint8_t uint8_t subframe2harq_pid_eNBrx(LTE_DL_FRAME_PARMS *frame_parms,uint8_t subframe); int generate_ue_dlsch_params_from_dci(int frame, - uint8_t subframe, + uint8_t subframe, void *dci_pdu, rnti_t rnti, DCI_format_t dci_format, @@ -1676,7 +1676,7 @@ uint16_t computeRIV(uint16_t N_RB_DL,uint16_t RBstart,uint16_t Lcrbs); /** \brief This routine expands a single (wideband) PMI to subband PMI bitmap similar to the one used in the UCI and in the dlsch_modulation routine @param frame_parms Pointer to DL frame configuration parameters - @param wideband_pmi (0,1,2,3 for rank 0 and 0,1 for rank 1) + @param wideband_pmi (0,1,2,3 for rank 0 and 0,1 for rank 1) @param rank (0 or 1) @returns subband PMI bitmap */ @@ -1684,7 +1684,7 @@ uint32_t pmi_extend(LTE_DL_FRAME_PARMS *frame_parms,uint8_t wideband_pmi, uint8_ /** \brief This routine extracts a single subband PMI from a bitmap coming from UCI or the pmi_extend function @param N_RB_DL number of resource blocks - @param mimo_mode + @param mimo_mode @param pmi_alloc subband PMI bitmap @param rb resource block for which to extract PMI @returns subband PMI @@ -1692,11 +1692,11 @@ uint32_t pmi_extend(LTE_DL_FRAME_PARMS *frame_parms,uint8_t wideband_pmi, uint8_ uint8_t get_pmi(uint8_t N_RB_DL,MIMO_mode_t mode, uint32_t pmi_alloc,uint16_t rb); int get_nCCE_offset_l1(int *CCE_table, - const unsigned char L, - const int nCCE, - const int common_dci, - const unsigned short rnti, - const unsigned char subframe); + const unsigned char L, + const int nCCE, + const int common_dci, + const unsigned short rnti, + const unsigned char subframe); uint16_t get_nCCE(uint8_t num_pdcch_symbols,LTE_DL_FRAME_PARMS *frame_parms,uint8_t mi); @@ -1758,22 +1758,22 @@ void generate_pucch_emul(PHY_VARS_UE *phy_vars_ue, uint32_t rx_pucch(PHY_VARS_eNB *phy_vars_eNB, - PUCCH_FMT_t fmt, - uint8_t UE_id, - uint16_t n1_pucch, - uint16_t n2_pucch, - uint8_t shortened_format, - uint8_t *payload, - int frame, - uint8_t subframe, - uint8_t pucch1_thres); + PUCCH_FMT_t fmt, + uint8_t UE_id, + uint16_t n1_pucch, + uint16_t n2_pucch, + uint8_t shortened_format, + uint8_t *payload, + int frame, + uint8_t subframe, + uint8_t pucch1_thres); int32_t rx_pucch_emul(PHY_VARS_eNB *phy_vars_eNB, - uint8_t UE_index, - PUCCH_FMT_t fmt, - uint8_t n1_pucch_sel, - uint8_t *payload, - uint8_t subframe); + uint8_t UE_index, + PUCCH_FMT_t fmt, + uint8_t n1_pucch_sel, + uint8_t *payload, + uint8_t subframe); /*! @@ -1865,18 +1865,19 @@ double get_pa_dB(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated); double computeRhoA_eNB(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated, LTE_eNB_DLSCH_t *dlsch_eNB, - int dl_power_off, - uint8_t n_antenna_port); + int dl_power_off, + uint8_t n_antenna_port); double computeRhoB_eNB(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated, PDSCH_CONFIG_COMMON *pdsch_config_common, uint8_t n_antenna_port, - LTE_eNB_DLSCH_t *dlsch_eNB,int dl_power_off); + LTE_eNB_DLSCH_t *dlsch_eNB, + int dl_power_off); double computeRhoA_UE(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated, LTE_UE_DLSCH_t *dlsch_ue, uint8_t dl_power_off, - uint8_t n_antenna_port); + uint8_t n_antenna_port); double computeRhoB_UE(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated, PDSCH_CONFIG_COMMON *pdsch_config_common, @@ -1890,7 +1891,7 @@ double computeRhoB_UE(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated, LTE_UE_DLSCH_t *dlsch_ue); */ -uint8_t get_prach_prb_offset(LTE_DL_FRAME_PARMS *frame_parms, uint8_t tdd_mapindex, uint16_t Nf); +uint8_t get_prach_prb_offset(LTE_DL_FRAME_PARMS *frame_parms, uint8_t tdd_mapindex, uint16_t Nf); uint8_t ul_subframe2pdcch_alloc_subframe(LTE_DL_FRAME_PARMS *frame_parms,uint8_t n); diff --git a/openair1/PHY/defs.h b/openair1/PHY/defs.h index 9d941d3bd60c1e8326533cd1e2415ec5efea980c..529f6297715969730c12936f46be31aa11545371 100755 --- a/openair1/PHY/defs.h +++ b/openair1/PHY/defs.h @@ -387,7 +387,7 @@ typedef struct PHY_VARS_eNB_s { #ifdef LOCALIZATION /// time state for localization time_stats_t localization_stats; -#endif +#endif int32_t pucch1_stats_cnt[NUMBER_OF_UE_MAX][10]; int32_t pucch1_stats[NUMBER_OF_UE_MAX][10*1024]; diff --git a/openair1/PHY/impl_defs_lte.h b/openair1/PHY/impl_defs_lte.h index e1736c9c9a123d8cf2eca6b27cca9b4914669055..b47f95d27035599355f89e3eebbbf3211ae57b15 100755 --- a/openair1/PHY/impl_defs_lte.h +++ b/openair1/PHY/impl_defs_lte.h @@ -793,7 +793,7 @@ typedef struct { /// - first index: ? [0..7] (hard coded) accessed via \c harq_pid /// - second index: ? [0..7] (hard coded) accessed via \c round /// - third index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx - /// - fourth index: ? [0..168*N_RB_DL[ + /// - fourth index: ? [0..168*N_RB_DL[ int32_t **rxdataF_comp1[8][8]; /// \brief Downlink channel estimates extracted in PRBS. /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx diff --git a/openair1/SIMULATION/LTE_PHY/dlsim.c b/openair1/SIMULATION/LTE_PHY/dlsim.c index 0b39a3580a3c7813a6daa776338f42bccc23ead4..e7408ac06a6cacfeee6fb31c3d91f5d884dcf0d5 100755 --- a/openair1/SIMULATION/LTE_PHY/dlsim.c +++ b/openair1/SIMULATION/LTE_PHY/dlsim.c @@ -38,6 +38,9 @@ \warning */ +//#define DEBUG_HARQ +//#define PRINT_THROUGHPUT + #include <string.h> #include <math.h> #include <unistd.h> @@ -163,6 +166,7 @@ int main(int argc, char **argv) int n_users = 1; int TB=0; RX_type_t rx_type=rx_standard; + unsigned char cur_harq_pid; SCM_t channel_model=Rayleigh1; @@ -262,6 +266,7 @@ int main(int argc, char **argv) double thr_cw0_tm4 = 0.0; double thr_cw0_tm4_nonconst = 0.0; double thr_cw0[4]={0,0,0,0}, thr_cw1[4]={0,0,0,0}, thr_cw0_tot = 0.0, thr_cw1_tot = 0.0; + double tbs0_init=0.0, tbs1_init=0.0, rate0_init=0.0, rate1_init=0.0; char channel_model_input[17]="I"; int TB0_active = 1; @@ -597,7 +602,7 @@ int main(int argc, char **argv) printf("-o Sample offset for receiver\n"); printf("-s Starting SNR, runs from SNR to SNR+%.1fdB in steps of %.1fdB. If n_frames is 1 then just SNR is simulated and MATLAB/OCTAVE output is generated\n", snr_int, snr_step); printf("-f step size of SNR, default value is 1.\n"); - printf("-r ressource block allocation (see section 7.1.6.3 in 36.213\n"); + printf("-r resource block allocation (see section 7.1.6.3 in 36.213\n"); printf("-g Channel model, possible values are 3GPP 25.814 SCM-A/B/C/D('A','B','C','D'), 36-101 EPA('E'), EVA ('F'),ETU('G'), Rayghleigh8 ('H'), Rayleigh1('I'), Rayleigh1_corr('J'), Rayleigh1_anticorr('K'), Rice8('L'), Rice1('M'), AWGN('N'), Rayleigh1_orthogonal('P'), Rayleigh1_orth_eff_ch_TM4_prec_real ('Q'), Rayleigh1_orth_eff_ch_TM4_prec_imag ('R'), Rayleigh8_orth_eff_ch_TM4_prec_real ('S'),Rayleigh8_orth_eff_ch_TM4_prec_imag ('T') \n"); printf("-F forgetting factor (0 new channel every trial, 1 channel constant\n"); printf("-x Transmission mode (1,2,6 for the moment)\n"); @@ -607,7 +612,7 @@ int main(int argc, char **argv) printf("-R Number of HARQ rounds (fixed)\n"); printf("-A Turns on calibration mode for abstraction.\n"); printf("-N Determines the number of Channel Realizations in Abstraction mode. Default value is 1. \n"); - printf("-O Set the percenatge of effective rate to testbench the modem performance (typically 30 and 70, range 1-100) \n"); + printf("-O Set the percentage of effective rate to testbench the modem performance (typically 30 and 70, range 1-100) \n"); printf("-I Input filename for TrCH data (binary)\n"); printf("-u Receiver type: 0=standard, 1 = single stream IC (for TM3,4,5,6), 2 = dual stream IC (for TM3,4), 3 = SIC (for TM3,4) \n"); exit(1); @@ -736,22 +741,26 @@ int main(int argc, char **argv) sprintf(bler_fname,"bler_tx%d_rec%d_chan%d_nrx%d_mcs%d_mcsi%d_u%d_imod%d.csv",transmission_mode,rx_type,channel_model,n_rx,mcs1,mcs_i,rx_type,i_mod); else if (abstx == 1) if (perfect_ce==1) - sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_mcs%d_mcsi%d_ab_pce_sh%d_pnort_r45.csv",transmission_mode,rx_type,channel_model,n_frames, n_rx,mcs1, mcs2,interf_unaw_shift ); + sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_rnd%d_mcs%d_mcsi%d_ab_pce_sh%d_rpmi4.csv",transmission_mode,rx_type,channel_model,n_frames, n_rx, num_rounds, mcs1, mcs2,interf_unaw_shift ); else - sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_mcs%d_mcsi%d_ab_sh%d_pnort_r45.csv",transmission_mode,rx_type,channel_model, n_frames, n_rx,mcs1, mcs2,interf_unaw_shift ); + sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_rnd%d_mcs%d_mcsi%d_ab_sh%d_rtpmi4.csv",transmission_mode,rx_type,channel_model, n_frames, n_rx, num_rounds, mcs1, mcs2,interf_unaw_shift ); else //abstx=0 if (perfect_ce==1) - sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_mcs%d_mcsi%d_pce_sh%d_pnort_r45.csv",transmission_mode,rx_type,channel_model,n_frames, n_rx,mcs1, mcs2, interf_unaw_shift); + sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_rnd%d_mcs%d_mcsi%d_pce_sh%d_rtpmi4.csv",transmission_mode,rx_type,channel_model,n_frames, n_rx, num_rounds, mcs1, mcs2, interf_unaw_shift); else - sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_mcs%d_mcsi%d_sh%d_pnort_r45.csv",transmission_mode,rx_type,channel_model,n_frames,n_rx,mcs1, mcs2, interf_unaw_shift); + sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_rnd%d_mcs%d_mcsi%d_sh%d_pnort_rtpmi4.csv",transmission_mode,rx_type,channel_model,n_frames,n_rx, num_rounds, mcs1, mcs2, interf_unaw_shift); bler_fd = fopen(bler_fname,"w"); if (bler_fd==NULL) { fprintf(stderr,"Cannot create file %s!\n",bler_fname); exit(-1); } + if ((transmission_mode != 3) && (transmission_mode != 4)) + fprintf(bler_fd,"SNR; MCS1; MCS2; TBS1; TBS2; rate 0; rate 1; err0_st1; err0_st2 trials0; err1_st1; err1_st2; trials1; err2_st1; err2_st2; trials2; err3_st1; err3_st2; trials3; throug 0; throug 1; sum throug; dci_err\n"); + else + fprintf(bler_fd,"SNR; MCS1; MCS2; TBS1; TBS2; rate 0; rate 1; err0_st1; err0_st2; trials0 r0; trials1 r0; err1_st1; err1_st2; trials0_r1; trials1_r1;; err2_st1; err2_st2; trials0_r2; trials1_r2; err3_st1; err3_st2; trials0_r3; trials1_r3; th0_r0; th1_r0; th_sum_r0; th0_r1; th1_r1; th_sum_r1; th0_r2; th1_r2; th_sum_r2; th0_r3; th1_r3; th_sum_r3; tot_th\n"); + - fprintf(bler_fd,"SNR; MCS1; MCS2; TBS1; TBS2; rate 0; rate 1; err0_st1; err0_st2 trials0; err1_st1; err1_st2; trials1; err2_st1; err2_st2; trials2; err3_st1; err3_st2; trials3; throug 0; throug 1; sum throug; dci_err\n"); if (test_perf != 0) { char hostname[1024]; @@ -791,104 +800,6 @@ int main(int argc, char **argv) } } - /* - //sprintf(tikz_fname, "second_bler_tx%d_u2=%d_mcs%d_chan%d_nsimus%d.tex",transmission_mode,dual_stream_UE,mcs,channel_model,n_frames); - sprintf(tikz_fname, "second_bler_tx%d_u2%d_mcs%d_chan%d_nsimus%d",transmission_mode,dual_stream_UE,mcs,channel_model,n_frames); - tikz_fd = fopesprintf(csv_fname,"dataout_tx%d_mcs%d_mcs_interf%d_chan%d_nsimus%d_R%d_abstr_old_perf_ce_llr.m",transmission_mode,mcs1,mcs2,channel_model,n_frames,num_rounds); -n(tikz_fname,"w"); - //fprintf(tikz_fd,"\\addplot[color=red, mark=o] plot coordinates {"); - switch (mcs) - { - case 0: - fprintf(tikz_fd,"\\addplot[color=blue, mark=star] plot coordinates {"); - break; - case 1: - fprintf(tikz_fd,"\\addplot[color=red, mark=star] plot coordinates {"); - break; - case 2: - fprintf(tikz_fd,"\\addplot[color=green, mark=star] plot coordinates {"); - break; - case 3: - fprintf(tikz_fd,"\\addplot[color=yellow, mark=star] plot coordinates {"); - break; - case 4: - fprintf(tikz_fd,"\\addplot[color=black, mark=star] plot coordinates {"); - break; - case 5: - fprintf(tikz_fd,"\\addplot[color=blue, mark=o] plot coordinates {"); - break; - case 6: - fprintf(tikz_fd,"\\addplot[color=red, mark=o] plot coordinates {"); - break; - case 7: - fprintf(tikz_fd,"\\addplot[color=green, mark=o] plot coordinates {"); - break; - case 8: - fprintf(tikz_fd,"\\addplot[color=yellow, mark=o] plot coordinates {"); - break; - case 9: - fprintf(tikz_fd,"\\addplot[color=black, mark=o] plot coordinates {"); - break; - case 10: - fprintf(tikz_fd,"\\addplot[color=blue, mark=square] plot coordinates {"); - break; - case 11: - fprintf(tikz_fd,"\\addplot[color=red, mark=square] plot coordinates {"); - break; - case 12: - fprintf(tikz_fd,"\\addplot[color=green, mark=square] plot coordinates {"); - break; - case 13: - fprintf(tikz_fd,"\\addplot[color=yellow, mark=square] plot coordinates {"); - break; - case 14: - fprintf(tikz_fd,"\\addplot[color=black, mark=square] plot coordinates {"); - break; - case 15: - fprintf(tikz_fd,"\\addplot[color=blue, mark=diamond] plot coordinates {"); - break; - case 16: - fprintf(tikz_fd,"\\addplot[color=red, mark=diamond] plot coordinates {"); - break; - case 17: - fprintf(tikz_fd,"\\addplot[color=green, mark=diamond] plot coordinates {"); - break; - case 18: - fprintf(tikz_fd,"\\addplot[color=yellow, mark=diamond] plot coordinates {"); - break; - case 19: - fprintf(tikz_fd,"\\addplot[color=black, mark=diamond] plot coordinates {"); - break; - case 20: - fprintf(tikz_fd,"\\addplot[color=blue, mark=x] plot coordinates {"); - break; - case 21: - fprintf(tikz_fd,"\\addplot[color=red, mark=x] plot coordinates {"); - break; - case 22: - fprintf(tikz_fd,"\\addplot[color=green, mark=x] plot coordinates {"); - break; - case 23: - fprintf(tikz_fd,"\\addplot[color=yellow, mark=x] plot coordinates {"); - break; - case 24: - fprintf(tikz_fd,"\\addplot[color=black, mark=x] plot coordinates {"); - break; - case 25: - fprintf(tikz_fd,"\\addplot[color=blue, mark=x] plot coordinates {"); - break; - case 26: - fprintf(tikz_fd,"\\addplot[color=red, mark=+] plot coordinates {"); - break; - case 27: - fprintf(tikz_fd,"\\addplot[color=green, mark=+] plot coordinates {"); - break; - case 28: - fprintf(tikz_fd,"\\addplot[color=yellow, mark=+] plot coordinates {"); - break; - } - */ - for (i=0; i<2; i++) { s_re[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double)); s_im[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double)); @@ -1048,15 +959,6 @@ n(tikz_fname,"w"); } if (input_fd==NULL) { - /* - // common DCI - memcpy(&dci_alloc[num_dci].dci_pdu[0],&CCCH_alloc_pdu,sizeof(DCI1A_5MHz_TDD_1_6_t)); - dci_alloc[num_dci].dci_length = sizeof_DCI1A_5MHz_TDD_1_6_t; - dci_alloc[num_dci].L = 2; - dci_alloc[num_dci].rnti = SI_RNTI; - num_dci++; - num_common_dci++; - */ // UE specific DCI for(k=0; k<n_users; k++) { @@ -2132,10 +2034,16 @@ n(tikz_fname,"w"); //printf("Trial %d\n",trials); fflush(stdout); round = 0; +#ifdef DEBUG_HARQ + printf("[DLSIM] TRIAL %d\n", trials); +#endif for (i=0; i<frame_parms->nb_antennas_tx; i++) { memset(sic_buffer[i], 0, FRAME_LENGTH_COMPLEX_SAMPLES_NO_PREFIX*sizeof(int32_t)); } + //PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->codeword], + //memset(PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[0], 0, (8*((3*8*6144)+12))*sizeof(int16_t)); + //memset(PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[1], 0, (8*((3*8*6144)+12))*sizeof(int16_t)); //if (trials%100==0) eNB2UE[0]->first_run = 1; @@ -2144,20 +2052,33 @@ n(tikz_fname,"w"); resend_cw0_cw1=1; resend_cw1=0; + TB0_active=1; while (((transmission_mode == 3 || transmission_mode == 4) && - ((round < num_rounds) && (ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations) && - (ret[1] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations))) || + ((round < num_rounds) && ((ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations) || + (ret[1] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations)))) || ((transmission_mode!=4 && transmission_mode != 3) && ((round< num_rounds) && (ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations)))) { +#ifdef DEBUG_HARQ + printf("\n [DLSIM] On top round is %d\n", round); +#endif - //printf("Trial %d, round %d , ret[0] %d, ret[1] %d, round_trials %d\n",trials,round, ret[0], ret[1], round_trials[round]); - if (ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations) round_trials[0][round]++; + round_trials[1][round]++; - if (ret[1] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations) + //printf("Trial %d, round %d , ret[0] %d, ret[1] %d, round_trials %d\n",trials,round, ret[0], ret[1], round_trials[round]); + + /*if (ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations) { + round_trials[0][round]++; round_trials[1][round]++; + } else if ((ret[1] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations) && (ret[0] <= PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations)) + round_trials[1][round]++;*/ + + +#ifdef DEBUG_HARQ + printf("[DLSIM] Just after while loop TB0 status %d round %d\n", TB0_active, round); +#endif // printf("Trial %d, round %d , ret[0] %d, ret[1] %d, round_trials TB0 = %d, round_trials TB1 = %d \n",trials,round, ret[0], ret[1], round_trials[0][round], round_trials[1][round]); @@ -2200,6 +2121,8 @@ n(tikz_fname,"w"); if (transmission_mode == 3 || transmission_mode == 4) PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->rvidx = round&3; + //printf("TB0 status %d round %d \n ", TB0_active, round); + if (round == 0) { // First round TB0_active = 1; @@ -2303,6 +2226,7 @@ n(tikz_fname,"w"); break; case 5: + case 6: DLSCH_alloc_pdu2_1E[0].ndi = trials&1; DLSCH_alloc_pdu2_1E[0].rv = 0; memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu2_1E[0],sizeof(DCI1E_5MHz_2A_M10PRB_TDD_t)); @@ -2401,6 +2325,7 @@ n(tikz_fname,"w"); } break; case 5: + case 6: DLSCH_alloc_pdu2_1E[0].ndi = trials&1; DLSCH_alloc_pdu2_1E[0].rv = 0; memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu2_1E[0],sizeof(DCI1E_5MHz_2A_M10PRB_TDD_t)); @@ -2512,7 +2437,7 @@ n(tikz_fname,"w"); ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2 = round&3; } else { // deactivate TB0 - ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi = 2; + ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi = 0; ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1 = 0; ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1 = 1; ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2 = trials&1; @@ -2528,14 +2453,29 @@ n(tikz_fname,"w"); ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2 = round&3; } else { // deactivate TB0 - printf("\n Requesting only TB1 from temp DCI\n"); - ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi = 2; +#ifdef DEBUG_HARQ + printf("\n[DLSIM] Requesting only TB1 from temp DCI\n"); +#endif + ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi = 4; ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1 = 0; ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1 = 1; ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2 = trials&1; ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2 = round&3; } memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu_1[0],sizeof(DCI2_5MHz_2A_TDD_t)); + generate_eNB_dlsch_params_from_dci(0, + subframe, + &DLSCH_alloc_pdu_1[0], + n_rnti+k, + format2, + PHY_vars_eNB->dlsch_eNB[0], + &PHY_vars_eNB->lte_frame_parms, + PHY_vars_eNB->pdsch_config_dedicated, + SI_RNTI, + 0, + P_RNTI, + PHY_vars_eNB->eNB_UE_stats[0].DL_pmi_single); + break; case 50: if (TB0_active==1) { @@ -2545,7 +2485,7 @@ n(tikz_fname,"w"); ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2 = round&3; } else { // deactivate TB0 - ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi = 2; + ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi = 0; ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1 = 0; ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1 = 1; ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2 = trials&1; @@ -2561,7 +2501,7 @@ n(tikz_fname,"w"); ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2 = round&3; } else { // deactivate TB0 - ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi = 2; + ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi = 0; ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1 = 0; ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1 = 1; ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2 = trials&1; @@ -2573,6 +2513,7 @@ n(tikz_fname,"w"); break; case 5: + case 6: DLSCH_alloc_pdu2_1E[0].ndi = trials&1; DLSCH_alloc_pdu2_1E[0].rv = round&3; memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu2_1E[0],sizeof(DCI1E_5MHz_2A_M10PRB_TDD_t)); @@ -2696,14 +2637,28 @@ n(tikz_fname,"w"); ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv2 = round&3; } else { // deactivate TB0 - printf("\n Requesting only TB1 from temp DCI\n"); - ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi = 2; +#ifdef DEBUG_HARQ + printf("\n [DLSIM] Requesting only TB1 from temp DCI\n"); +#endif + ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi = 4; ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1 = 0; ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1 = 1; ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2 = trials&1; ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv2 = round&3; } memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu_1[0],sizeof(DCI2_5MHz_2A_FDD_t)); + generate_eNB_dlsch_params_from_dci(0, + subframe, + &DLSCH_alloc_pdu_1[0], + n_rnti+k, + format2, + PHY_vars_eNB->dlsch_eNB[0], + &PHY_vars_eNB->lte_frame_parms, + PHY_vars_eNB->pdsch_config_dedicated, + SI_RNTI, + 0, + P_RNTI, + PHY_vars_eNB->eNB_UE_stats[0].DL_pmi_single); break; case 50: if (TB0_active==1) { @@ -2713,7 +2668,7 @@ n(tikz_fname,"w"); ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv2 = round&3; } else { // deactivate TB0 - ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi = 2; + ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi = 0; ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1 = 0; ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1 = 1; ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2 = trials&1; @@ -2729,7 +2684,7 @@ n(tikz_fname,"w"); ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv2 = round&3; } else { // deactivate TB0 - ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi = 2; + ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi = 0; ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1 = 0; ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1 = 1; ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2 = trials&1; @@ -2742,6 +2697,7 @@ n(tikz_fname,"w"); case 5: + case 6: DLSCH_alloc_pdu2_1E[0].ndi = trials&1; DLSCH_alloc_pdu2_1E[0].rv = round&3; memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu2_1E[0],sizeof(DCI1E_5MHz_2A_M10PRB_TDD_t)); @@ -2764,10 +2720,18 @@ n(tikz_fname,"w"); exit(-1); } - for (k=0;k<n_users;k++) { + for (k=0;k<n_users;k++) { for (int TB=0; TB<Kmimo; TB++) { - if (PHY_vars_eNB->dlsch_eNB[0][TB] == NULL) - continue; + if (TB0_active == 0){ +#ifdef DEBUG_HARQ + printf("[DLSIM ENC] Skip TB0 \n"); +#endif + TB++; + + } +#ifdef DEBUG_HARQ + printf("[DLSIM ENC] process TB %d \n", TB); +#endif coded_bits_per_codeword[TB] = get_G(&PHY_vars_eNB->lte_frame_parms, PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->nb_rb, @@ -2776,8 +2740,6 @@ n(tikz_fname,"w"); PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->Nl, num_pdcch_symbols, 0,subframe); - - #ifdef TBS_FIX // This is for MESH operation!!! tbs[TB] = (double)3*TBStable[get_I_TBS(PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->mcs)][PHY_vars_eNB->dlsch_eNB[k][TB]->nb_rb-1]/4; #else @@ -2842,7 +2804,7 @@ n(tikz_fname,"w"); subframe<<1); stop_meas(&PHY_vars_eNB->dlsch_scrambling_stats); - if (n_frames==1) { + if (n_frames==2) { for (s=0;s<PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->C;s++) { if (s<PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->Cminus) Kr = PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->Kminus; @@ -2859,11 +2821,19 @@ n(tikz_fname,"w"); subframe, &PHY_vars_eNB->lte_frame_parms, num_pdcch_symbols, - PHY_vars_eNB->dlsch_eNB[k][0], + ((TB0_active == 1)? PHY_vars_eNB->dlsch_eNB[k][0]: NULL), PHY_vars_eNB->dlsch_eNB[k][1]); stop_meas(&PHY_vars_eNB->dlsch_modulation_stats); } //n_users + + if (((transmission_mode == 3) || (transmission_mode == 4)) && (SNR == snr0) && (trials == 0) && (round == 0)){ + rate0_init = rate[0]; + rate1_init = rate[1]; + tbs0_init=tbs[0]; + tbs1_init=tbs[1]; + } + generate_pilots(PHY_vars_eNB, PHY_vars_eNB->lte_eNB_common_vars.txdataF[eNB_id], AMP, @@ -2889,7 +2859,7 @@ n(tikz_fname,"w"); (subframe*2)+2, &PHY_vars_eNB->lte_frame_parms); - if (n_frames==1) { + if (n_frames==2) { write_output("txsigF0.m","txsF0", &PHY_vars_eNB->lte_eNB_common_vars.txdataF[eNB_id][0][subframe*nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size],nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size,1,1); if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx>1) write_output("txsigF1.m","txsF1", &PHY_vars_eNB->lte_eNB_common_vars.txdataF[eNB_id][1][subframe*nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size],nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size,1,1); @@ -2903,7 +2873,7 @@ n(tikz_fname,"w"); } tx_lev_dB = (unsigned int) dB_fixed(tx_lev); - if (n_frames==1) { + if (n_frames==2) { write_output("txsigF0.m","txsF0", &PHY_vars_eNB->lte_eNB_common_vars.txdataF[eNB_id][0][subframe*nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size],nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size,1,1); if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx>1) write_output("txsigF1.m","txsF1", &PHY_vars_eNB->lte_eNB_common_vars.txdataF[eNB_id][1][subframe*nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size],nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size,1,1); @@ -2917,7 +2887,7 @@ n(tikz_fname,"w"); } tx_lev_dB = (unsigned int) dB_fixed(tx_lev); - if (n_frames==1) { + if (n_frames==2) { printf("tx_lev = %d (%d dB)\n",tx_lev,tx_lev_dB); write_output("txsig0.m","txs0", &PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][0][subframe* PHY_vars_eNB->lte_frame_parms.samples_per_tti], PHY_vars_eNB->lte_frame_parms.samples_per_tti,1,1); } @@ -3061,7 +3031,7 @@ n(tikz_fname,"w"); // This is the SNR on the PDSCH for OFDM symbols without pilots -> rho_A sigma2_dB = 10*log10((double)tx_lev) +10*log10((double)PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size/(double)(NB_RB*12)) - SNR - get_pa_dB(PHY_vars_eNB->pdsch_config_dedicated); sigma2 = pow(10,sigma2_dB/10); - if (n_frames==1) + if (n_frames==2) printf("Sigma2 %f (sigma2_dB %f,%f,%f )\n",sigma2,sigma2_dB,10*log10((double)PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size/(double)(NB_RB*12)),get_pa_dB(PHY_vars_eNB->pdsch_config_dedicated)); for (i=0; i<2*frame_parms->samples_per_tti; i++) { @@ -3094,7 +3064,7 @@ n(tikz_fname,"w"); fclose(rx_frame_file); */ - if (n_frames==1) { + if (n_frames==2) { printf("RX level in null symbol %d\n",dB_fixed(signal_energy(&PHY_vars_UE->lte_ue_common_vars.rxdata[0][160+OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES],OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2))); printf("RX level in data symbol %d\n",dB_fixed(signal_energy(&PHY_vars_UE->lte_ue_common_vars.rxdata[0][160+(2*OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES)],OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2))); printf("rx_level Null symbol %f\n",10*log10(signal_energy_fp(r_re,r_im,1,OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2,256+(OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES)))); @@ -3116,7 +3086,7 @@ n(tikz_fname,"w"); // Inner receiver scheduling for 3 slots for (Ns=(2*subframe);Ns<((2*subframe)+3);Ns++) { for (l=0;l<pilot2;l++) { - if (n_frames==1) + if (n_frames==2) printf("Ns %d, l %d, l2 %d\n",Ns, l, l+(Ns%2)*pilot2); /* This function implements the OFDM front end processor (FEP). @@ -3213,6 +3183,7 @@ n(tikz_fname,"w"); pmi_feedback = 0; hold_channel = 1; //printf ("trial %d pmi_feedback %d \n", trials, pmi_feedback); + //printf ("go to PMI feedback\n"); goto PMI_FEEDBACK; } } @@ -3251,7 +3222,7 @@ n(tikz_fname,"w"); round=5; // this is meant to stop the "while" loop if DCI is wrong; errs[0][0]++; - if (n_frames==1) + if (n_frames==2) printf("DCI error trial %d errs[0][0] %d\n",trials,errs[0][0]); } } @@ -3309,7 +3280,7 @@ n(tikz_fname,"w"); errs[0][0]++; round=5; - if (n_frames==1) + if (n_frames==2) printf("DCI misdetection trial %d\n",trials); } @@ -3389,9 +3360,14 @@ n(tikz_fname,"w"); } if (dlsch_active == 1) { + if (TB0_active==1) + cur_harq_pid =PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid; + else + cur_harq_pid =PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid; + if ((Ns==(1+(2*subframe))) && (l==0)) {// process PDSCH symbols 1,2,3,4,5,(6 Normal Prefix if (transmission_mode == 5) { - if ((PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid]->dl_power_off==0) && + if ((PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[cur_harq_pid]->dl_power_off==0) && (openair_daq_vars.use_ia_receiver ==1)) { rx_type = rx_IC_single_stream; } else { @@ -3403,6 +3379,7 @@ n(tikz_fname,"w"); start_meas(&PHY_vars_UE->dlsch_llr_stats); for (m=PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols; m<pilot2; m++) { + if (rx_pdsch(PHY_vars_UE, PDSCH, eNB_id, @@ -3412,7 +3389,7 @@ n(tikz_fname,"w"); (m==PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols)?1:0, rx_type, i_mod, - PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid)==-1){ + cur_harq_pid)==-1){ dlsch_active = 0; break; } @@ -3432,7 +3409,7 @@ n(tikz_fname,"w"); 0, rx_type, i_mod, - PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid)==-1){ + cur_harq_pid)==-1){ dlsch_active=0; break; } @@ -3452,7 +3429,7 @@ n(tikz_fname,"w"); 0, rx_type, i_mod, - PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid)==-1) { + cur_harq_pid)==-1) { dlsch_active=0; break; } @@ -3485,8 +3462,22 @@ n(tikz_fname,"w"); for (TB=0; TB<Kmimo; TB++){ // may be we ll have to swap CW - if (PHY_vars_UE->dlsch_ue[0][TB] == NULL) - continue; + /* if (PHY_vars_UE->dlsch_ue[0][TB] == NULL){ + printf("[DLSIM] PHY_vars_UE->dlsch_ue[0][TB] == NULL\n"); + printf("HERE HERE HERE HERE\n"); + continue; + }*/ + + if (TB0_active == 0){ +#ifdef DEBUG_HARQ + printf("[DLSIM] Skip TB0 \n"); +#endif + TB++; + + } +#ifdef DEBUG_HARQ + printf("[DLSIM] process TB %d \n", TB); +#endif PHY_vars_UE->dlsch_ue[0][TB]->rnti = (common_flag==0) ? n_rnti: SI_RNTI; coded_bits_per_codeword[TB] = get_G(&PHY_vars_eNB->lte_frame_parms, @@ -3500,7 +3491,7 @@ n(tikz_fname,"w"); PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid]->G = coded_bits_per_codeword[TB]; PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid]->Qm = get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->mcs); - if (n_frames==1) { + if (n_frames==2) { printf("Kmimo=%d, TB=%d, G=%d, TBS=%d\n",Kmimo,TB,coded_bits_per_codeword[TB], PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid]->TBS); @@ -3551,21 +3542,27 @@ n(tikz_fname,"w"); start_meas(&PHY_vars_UE->dlsch_decoding_stats); ret[TB] = dlsch_decoding(PHY_vars_UE, - PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[TB], - &PHY_vars_UE->lte_frame_parms, - PHY_vars_UE->dlsch_ue[0][TB], - PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid], - subframe, - PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid, - 1,llr8_flag); + PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid]->codeword], + &PHY_vars_UE->lte_frame_parms, + PHY_vars_UE->dlsch_ue[0][TB], + PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid], + subframe, + PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid, + 1,llr8_flag); stop_meas(&PHY_vars_UE->dlsch_decoding_stats); +#ifdef DEBUG_HARQ + printf("[DLSIM] ret[%d] = %d\n", TB, ret[TB]); +#endif + //printf("retr cw 0 = %d\n", ret[0]); //printf("current round = %d\n", PHY_vars_UE->dlsch_ue[0][cw_non_sic]->harq_processes[PHY_vars_UE->dlsch_ue[0][cw_non_sic]->current_harq_pid]->round); if (ret[TB] <= PHY_vars_UE->dlsch_ue[0][TB]->max_turbo_iterations ) { //if CW0 is decoded, approach CW1 - +#ifdef DEBUG_HARQ + printf("[DLSIM] TB%d is decoded\n", TB); +#endif /*avg_iter[TB] += ret[TB]; iter_trials[TB]++;*/ @@ -3690,8 +3687,11 @@ n(tikz_fname,"w"); } if ((PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) && - (PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode <=DUALSTREAM_PUSCH_PRECODING) && - rx_type==rx_SIC_dual_stream) { + (PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode <=DUALSTREAM_PUSCH_PRECODING) && (TB0_active == 1) && + (rx_type==rx_SIC_dual_stream)) { +#ifdef DEBUG_HARQ + printf("[DLSIM] Starting SIC procedure\n"); +#endif // printf("current round = %d\n", PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->round); @@ -3699,10 +3699,14 @@ n(tikz_fname,"w"); //printf("\n ret[TB0] = %d round %d\n", ret[TB], round); for (round_sic = 0 ; round_sic < (round +1); round_sic++) { + +#ifdef DEBUG_HARQ + printf("[DLSIM] 0 Round sic = %d\n", round_sic); +#endif //printf("I enter round_sic loop \n"); //printf("round_sic= %d\n", round_sic); - dlsch0_ue_harq = PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]; - dlsch0_eNB_harq = PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]; + dlsch0_ue_harq = PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][1]->current_harq_pid]; + dlsch0_eNB_harq = PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][1]->current_harq_pid]; dlsch0_eNB_harq->mimo_mode = PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode; dlsch0_eNB_harq->rb_alloc[0] = dlsch0_ue_harq->rb_alloc_even[0]; @@ -3730,7 +3734,7 @@ n(tikz_fname,"w"); &PHY_vars_UE->dlsch_interleaving_stats); - coded_bits_per_codeword[TB]= get_G(&PHY_vars_UE->lte_frame_parms, + coded_bits_per_codeword[0]= get_G(&PHY_vars_UE->lte_frame_parms, PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_eNB[eNB_id]->current_harq_pid]->nb_rb, PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_eNB[eNB_id]->current_harq_pid]->rb_alloc, get_Qm(PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_eNB[eNB_id]->current_harq_pid]->mcs), @@ -3752,38 +3756,39 @@ n(tikz_fname,"w"); num_pdcch_symbols, &PHY_vars_UE->dlsch_eNB[0][0], NULL, - coded_bits_per_codeword[TB]); + coded_bits_per_codeword[0]); // write_output("sic_buffer.m","sic", *sic_buffer,re_allocated,1,1); // write_output("rxdataF_comp1.m","rxF_comp1", *PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round],14*12*25,1,1); // write_output("rxdataF_rho.m","rho", *PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round],14*12*25,1,1); - switch (get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->mcs)){ + switch (get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)){ + case 2: dlsch_qpsk_llr_SIC(&PHY_vars_UE->lte_frame_parms, - PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic], + PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic], sic_buffer, - PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic], - PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword], + PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic], + PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->codeword], num_pdcch_symbols, dlsch0_eNB_harq->nb_rb, subframe, dlsch0_eNB_harq->rb_alloc[0], - get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->mcs), - PHY_vars_UE->dlsch_ue[eNB_id][TB]); + get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs), + PHY_vars_UE->dlsch_ue[eNB_id][0]); break; case 4: dlsch_16qam_llr_SIC(&PHY_vars_UE->lte_frame_parms, - PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic], + PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic], sic_buffer, - PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic], - PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword], + PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic], + PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->codeword], num_pdcch_symbols, - PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic], + PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic], dlsch0_eNB_harq->nb_rb, subframe, dlsch0_eNB_harq->rb_alloc[0], @@ -3792,67 +3797,70 @@ n(tikz_fname,"w"); break; case 6: dlsch_64qam_llr_SIC(&PHY_vars_UE->lte_frame_parms, - PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic], + PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic], sic_buffer, - PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic], - PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword], + PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic], + PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->codeword], num_pdcch_symbols, - PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic], - PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_magb1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic], + PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic], + PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_magb1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic], dlsch0_eNB_harq->nb_rb, subframe, dlsch0_eNB_harq->rb_alloc[0], - get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->mcs), + get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs), PHY_vars_UE->dlsch_ue[eNB_id][TB]); break; } - } + //}// rouns sic +#ifdef DEBUG_HARQ + printf("[DLSIM] TB1 is mapped into CW%d\n", PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->codeword); +#endif // write_output("rxdata_llr1.m","llr1", PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[1],re_allocated*2,1,0); // replace cw_sic with TB+1 - PHY_vars_UE->dlsch_ue[0][TB+1]->rnti = (common_flag==0) ? n_rnti: SI_RNTI; - coded_bits_per_codeword[TB+1]= get_G(&PHY_vars_eNB->lte_frame_parms, - PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->nb_rb, - PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->rb_alloc, - get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->mcs), - PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->Nl, + PHY_vars_UE->dlsch_ue[0][1]->rnti = (common_flag==0) ? n_rnti: SI_RNTI; + coded_bits_per_codeword[1]= get_G(&PHY_vars_eNB->lte_frame_parms, + PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->nb_rb, + PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->rb_alloc, + get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs), + PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->Nl, num_pdcch_symbols, 0, subframe); - PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->G = coded_bits_per_codeword[TB+1]; - PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->Qm = get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->mcs); + PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->G = coded_bits_per_codeword[1]; + PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->Qm = get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs); - if (n_frames==1) { - printf("Kmimo=%d, cw=%d, G=%d, TBS=%d\n",Kmimo,TB+1,coded_bits_per_codeword[TB+1], - PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->TBS); + if (n_frames==2) { + printf("Kmimo=%d, cw=%d, G=%d, TBS=%d\n",Kmimo,1,coded_bits_per_codeword[1], + PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->TBS); // calculate uncoded BER - uncoded_ber_bit = (short*) malloc(sizeof(short)*coded_bits_per_codeword[TB+1]); + uncoded_ber_bit = (short*) malloc(sizeof(short)*coded_bits_per_codeword[1]); AssertFatal(uncoded_ber_bit, "uncoded_ber_bit==NULL"); - sprintf(fname,"dlsch%d_rxF_r%d_cw%d_llr.m",eNB_id,round, TB+1); - sprintf(vname,"dl%d_r%d_cw%d_llr",eNB_id,round, TB+1); - write_output(fname,vname, PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[TB+1],coded_bits_per_codeword[TB+1],1,0); - sprintf(fname,"dlsch_cw%d_e.m", TB+1); - sprintf(vname,"dlschcw%d_e", TB+1); - write_output(fname, vname,PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->e,coded_bits_per_codeword[TB+1],1,4); + sprintf(fname,"dlsch%d_rxF_r%d_cw%d_llr.m",eNB_id,round,1); + sprintf(vname,"dl%d_r%d_cw%d_llr",eNB_id,round, 1); + write_output(fname,vname, PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[1],coded_bits_per_codeword[1],1,0); + sprintf(fname,"dlsch_cw%d_e.m", 1); + sprintf(vname,"dlschcw%d_e", 1); + write_output(fname, vname,PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->e,coded_bits_per_codeword[1],1,4); uncoded_ber=0; printf("trials=%d\n", trials); - for (i=0;i<coded_bits_per_codeword[TB+1];i++) - if (PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->e[i] != (PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword][i]<0)) { + for (i=0;i<coded_bits_per_codeword[1];i++) + if (PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->e[i] != (PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->codeword][i]<0)) { uncoded_ber_bit[i] = 1; uncoded_ber++; } else uncoded_ber_bit[i] = 0; - uncoded_ber/=coded_bits_per_codeword[TB+1]; + uncoded_ber/=coded_bits_per_codeword[1]; avg_ber += uncoded_ber; - sprintf(fname,"cw%d_uncoded_ber_bit.m", TB+1); - sprintf(vname,"uncoded_ber_bit_cw%d", TB+1); - write_output(fname, vname,uncoded_ber_bit,coded_bits_per_codeword[TB+1],1,0); - printf("cw %d, uncoded ber %f\n",TB+1,uncoded_ber); + sprintf(fname,"cw%d_uncoded_ber_bit.m", 1); + sprintf(vname,"uncoded_ber_bit_cw%d", 1); + write_output(fname, vname,uncoded_ber_bit,coded_bits_per_codeword[1],1,0); + printf("cw %d, uncoded ber %f\n",1,uncoded_ber); free(uncoded_ber_bit); uncoded_ber_bit = NULL; } @@ -3860,84 +3868,102 @@ n(tikz_fname,"w"); start_meas(&PHY_vars_UE->dlsch_unscrambling_stats); dlsch_unscrambling(&PHY_vars_UE->lte_frame_parms, 0, - PHY_vars_UE->dlsch_ue[0][TB+1], - coded_bits_per_codeword[TB+1], - PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword], - TB+1, + PHY_vars_UE->dlsch_ue[0][1], + coded_bits_per_codeword[1], + PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->codeword], + 1, subframe<<1); stop_meas(&PHY_vars_UE->dlsch_unscrambling_stats); start_meas(&PHY_vars_UE->dlsch_decoding_stats); ret[1] = dlsch_decoding(PHY_vars_UE, - PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword], + PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->codeword], &PHY_vars_UE->lte_frame_parms, - PHY_vars_UE->dlsch_ue[0][TB+1], - PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid], + PHY_vars_UE->dlsch_ue[0][1], + PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid], subframe, - PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid, + PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid, 1,llr8_flag); stop_meas(&PHY_vars_UE->dlsch_decoding_stats); - //printf("ret TB 1 = %d round %d \n", ret[1], round); +#ifdef DEBUG_HARQ + printf("[DLSIM] Decoding TB1 in SIC: ret[1] = %d, round sic %d\n", ret[1], round_sic); +#endif - if (ret[TB+1] <= PHY_vars_UE->dlsch_ue[0][TB+1]->max_turbo_iterations ) { + //printf("ret TB 1 = %d round %d \n", ret[1], round); - avg_iter[TB+1] += ret[TB+1]; - iter_trials[TB+1]++; + if (ret[1] <= PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations ) { + round_sic = round+1; // to exit round_sic +#ifdef DEBUG_HARQ + printf("[DLSIM] TB1 is decoded in SIC loop\n"); +#endif + avg_iter[1] += ret[1]; + iter_trials[1]++; - if (n_frames==1) { - printf("cw sic %d, round %d: No DLSCH errors found, uncoded ber %f\n",TB+1,round,uncoded_ber); + if (n_frames==2) { + printf("cw sic %d, round %d: No DLSCH errors found, uncoded ber %f\n",1,round,uncoded_ber); #ifdef PRINT_BYTES - for (s=0;s<PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->C;s++) { - if (s<PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->Cminus) - Kr = PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->Kminus; + for (s=0;s<PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->C;s++) { + if (s<PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->Cminus) + Kr = PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->Kminus; else - Kr = PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->Kplus; + Kr = PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->Kplus; Kr_bytes = Kr>>3; printf("Decoded_output (Segment %d):\n",s); for (i=0;i<Kr_bytes;i++) - printf("%d : %x (%x)\n",i,PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->c[s][i], - PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->c[s][i]); + printf("%d : %x (%x)\n",i,PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->c[s][i], + PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->c[s][i]); } #endif } - } else{ - errs[TB+1][round]++; + } + } //round_sic + + + if (ret[1] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations ){ + errs[1][round]++; +#ifdef DEBUG_HARQ + printf("[DLSIM] TB1 is not decoded in SIC loop, errs[TB1][round %d] = %d\n",round, errs[1][round]); +#endif + // exit(0); - avg_iter[TB+1] += ret[TB+1]-1; - iter_trials[TB+1]++; + avg_iter[1] += ret[1]-1; + iter_trials[1]++; - if (n_frames==1) { + if (n_frames==2) { //if ((n_frames==1) || (SNR>=30)) { - printf("cw sic %d, round %d: DLSCH errors found, uncoded ber %f\n",TB+1,round,uncoded_ber); + printf("cw sic %d, round %d: DLSCH errors found, uncoded ber %f\n",1,round,uncoded_ber); #ifdef PRINT_BYTES - for (s=0;s<PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->C;s++) { - if (s<PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->Cminus) - Kr = PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->Kminus; + for (s=0;s<PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->C;s++) { + if (s<PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->Cminus) + Kr = PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->Kminus; else - Kr = PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->Kplus; + Kr = PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->Kplus; Kr_bytes = Kr>>3; printf("Decoded_output (Segment %d):\n",s); for (i=0;i<Kr_bytes;i++) - printf("%d : %x (%x)\n",i,PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->c[s][i], - PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->c[s][i]); + printf("%d : %x (%x)\n",i,PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->c[s][i], + PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->c[s][i]); } #endif } //n_frames==1 // exit(0); - } //if (ret > PHY_vars_UE->dlsch_ue[0][TB+1]->max_turbo_iterations ) + } //if (ret > PHY_vars_UE->dlsch_ue[0][1]->max_turbo_iterations ) }//if SIC } else { errs[TB][round]++; +#ifdef DEBUG_HARQ + printf("[DLSIM] TB%d is not decoded outside SIC loop, errs[TB%d][round %d] = %d\n", TB, TB, round, errs[TB][round]); +#endif /*if (cw_non_sic==0) { @@ -3947,17 +3973,21 @@ n(tikz_fname,"w"); if ((PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) && (PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode <=DUALSTREAM_PUSCH_PRECODING) && - (rx_type==rx_SIC_dual_stream)) { - errs[TB+1][round]++; + (rx_type==rx_SIC_dual_stream) && (TB0_active ==1)) { + errs[1][round]++; +#ifdef DEBUG_HARQ + printf("[DLSIM] HERE OR NOT TB%d is not decoded outside SIC loop, errs[TB%d][round %d] = %d\n", 1, 1, round, errs[1][round]); +#endif } + /*if (cw_non_sic==1) { avg_iter[1] += ret[1]-1; iter_trials[1]++; }*/ - if (n_frames==1) { + if (n_frames==2) { //if ((n_frames==1) || (SNR>=30)) { printf("cw %d, round %d: DLSCH errors found, uncoded ber %f\n",TB,round,uncoded_ber); #ifdef PRINT_BYTES @@ -3982,7 +4012,7 @@ n(tikz_fname,"w"); stop_meas(&PHY_vars_UE->phy_proc_rx); - if (n_frames==1) { + if (n_frames==2) { //rxsig sprintf(fname,"rxsig0_r%d.m",round); @@ -4068,10 +4098,11 @@ n(tikz_fname,"w"); 0,// UE_id subframe); } +#ifdef DEBUG_HARQ + printf("[DLSIM] Errors errs[TB0][round %d] = %d, errs[TB1][round %d] = %d\n ", round, errs[0][round], round, errs[1][round]); +#endif - - - if ((transmission_mode != 3 && transmission_mode !=4 ) && ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations){ + if ((transmission_mode != 3) && (transmission_mode !=4) && (ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations)){ //printf("flag 1 \n"); round++; } @@ -4083,20 +4114,23 @@ n(tikz_fname,"w"); resend_cw0_cw1=1; //resend both cws resend_cw1=0; TB0_active=1; - //printf("flag 2 \n"); } if ((transmission_mode == 3 || transmission_mode == 4 ) && (ret[1] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations ) && (ret[0] <= PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations)){ resend_one[round]++; - round++; resend_cw0_cw1=0; TB0_active=0; - //PHY_vars_UE->PHY_measurements.rank[eNB_id]=0; - // printf("\n DLSIM TB0 disactivated\n"); - //printf("flag 3 \n"); - +#ifdef DEBUG_HARQ + printf("[DLSIM] ret[TB0] =%d, ret[TB1] =%d, trial %d \n", ret[0], ret[1], trials); + printf("[DLSIM] TB0 deactivated\n"); +#endif + round++; } +#ifdef DEBUG_HARQ + printf("[DLSIM] Now round is %d, trial %d\n" , round, trials); +#endif + } @@ -4265,21 +4299,31 @@ n(tikz_fname,"w"); if (transmission_mode == 3 || transmission_mode == 4) { // FOR CW0 - thr_cw0[0] = rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)*(1-((double)errs[0][0]/(double)round_trials[0][0])); - thr_cw0[1] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)/2)*(((double)errs[0][0] - (double)errs[0][1])/(double)round_trials[0][0]); - thr_cw0[2] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)/3)*(((double)errs[0][1] - (double)errs[0][2])/(double)round_trials[0][0]); - thr_cw0[3] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)/4)*(((double)errs[0][2] - (double)errs[0][3])/(double)round_trials[0][0]); + thr_cw0[0] = rate0_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)*(1-((double)errs[0][0]/(double)round_trials[0][0])); + thr_cw0[1] = (rate0_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)/2)*(((double)errs[0][0] - (double)errs[0][1])/(double)round_trials[0][0]); + thr_cw0[2] = (rate0_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)/3)*(((double)errs[0][1] - (double)errs[0][2])/(double)round_trials[0][0]); + thr_cw0[3] = (rate0_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)/4)*(((double)errs[0][2] - (double)errs[0][3])/(double)round_trials[0][0]); thr_cw0_tot = (double)thr_cw0[0]+(double)thr_cw0[1]+(double)thr_cw0[2]+(double)thr_cw0[3]; - printf("\n Throughput cw0 sum = %f \n", thr_cw0_tot); +#ifdef PRINT_THROUGHPUT + printf("rate %f \n", rate0_init); + printf("rate*mod_order %f \n", rate0_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)); + printf("Probability %f \n", (1-((double)errs[0][0]/(double)round_trials[0][0]))); + printf("Throughput cw0 sum = %f \n", thr_cw0_tot); + printf("Throughput cw0 round 0 = %f \n", thr_cw0[0]); + printf("Throughput cw0 round 1 = %f \n", thr_cw0[1]); + printf("Throughput cw0 round 2 = %f \n", thr_cw0[2]); + printf("Throughput cw0 round 3 = %f \n", thr_cw0[3]); printf("round_trials = %d, errs[0][0] = %d, round_trials[0][1] = %d, errs[0][1] = %d, round_trials[0][2] = %d, errs[0][2] = %d, \ round_trials[0][3] = %d, errs[0][3] = %d \n", round_trials[0][0], errs[0][0],round_trials[0][1], errs[0][1], round_trials[0][2], \ errs[0][2], round_trials[0][3], errs[0][3]); +#endif - thr_cw1[0] = rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)*(1-((double)errs[1][0]/(double)round_trials[1][0])); - thr_cw1[1] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)/2)*(((double)errs[1][0] - (double)errs[1][1])/(double)round_trials[1][0]); - thr_cw1[2] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)/3)*(((double)errs[1][1] - (double)errs[1][2])/(double)round_trials[1][0]); - thr_cw1[3] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)/4)*(((double)errs[1][2] - (double)errs[1][3])/(double)round_trials[1][0]); + thr_cw1[0] = rate1_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)*(1-((double)errs[1][0]/(double)round_trials[1][0])); + thr_cw1[1] = (rate1_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)/2)*(((double)errs[1][0] - (double)errs[1][1])/(double)round_trials[1][0]); + thr_cw1[2] = (rate1_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)/3)*(((double)errs[1][1] - (double)errs[1][2])/(double)round_trials[1][0]); + thr_cw1[3] = (rate1_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)/4)*(((double)errs[1][2] - (double)errs[1][3])/(double)round_trials[1][0]); thr_cw1_tot = (double)thr_cw1[0]+(double)thr_cw1[1]+(double)thr_cw1[2]+(double)thr_cw1[3]; +#ifdef PRINT_THROUGHPUT printf("Throughput cw1 sum = %f \n", thr_cw1_tot); printf("Throughput cw1 round 0 = %f \n", thr_cw1[0]); printf("Throughput cw1 round 1 = %f \n", thr_cw1[1]); @@ -4288,6 +4332,7 @@ n(tikz_fname,"w"); printf("round_trials[1][0] = %d, errs[1][0] = %d, round_trials[1][1] = %d, errs[1][1] = %d, round_trials[1][2] = %d, errs[1][2] = %d, \ round_trials[1][3] = %d, errs[1][3] = %d \n", round_trials[1][0], errs[1][0], round_trials[1][1], errs[1][1], round_trials[1][2], \ errs[1][2], round_trials[1][3], errs[1][3]); +#endif } #if 0 @@ -4494,27 +4539,39 @@ n(tikz_fname,"w"); SNR, mcs1, mcs2, - PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->TBS, - PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->TBS, - rate[0], - rate[1], + tbs0_init, + tbs1_init, + rate0_init, + rate1_init, errs[0][0], errs[1][0], round_trials[0][0], + round_trials[1][0], errs[0][1], errs[1][1], round_trials[0][1], + round_trials[1][1], errs[0][2], errs[1][2], round_trials[0][2], + round_trials[1][2], errs[0][3], errs[1][3], round_trials[0][3], - rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)*(1-((double)errs[0][0]/(double)round_trials[0][0])), - rate[1]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)*(1-((double)errs[1][0]/(double)round_trials[1][0])), - rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)*(1-((double)errs[0][0]/(double)round_trials[0][0]))+ - rate[1]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)*(1-((double)errs[1][0]/(double)round_trials[1][0])), - dci_errors); + round_trials[1][3], + thr_cw0[0], + thr_cw1[0], + thr_cw0[0]+thr_cw1[0], + thr_cw0[1], + thr_cw1[1], + thr_cw0[1]+thr_cw1[1], + thr_cw0[2], + thr_cw1[2], + thr_cw0[2]+thr_cw1[2], + thr_cw0[3], + thr_cw1[3], + thr_cw0[3]+thr_cw1[3], + thr_cw0[0]+thr_cw0[1]+thr_cw0[2]+thr_cw0[4]+thr_cw1[0]+thr_cw1[1]+thr_cw1[2]+ thr_cw1[3]); } @@ -4742,7 +4799,7 @@ n(tikz_fname,"w"); } - if (n_frames==1) + if (n_frames==2) break; }// SNR diff --git a/openair1/SIMULATION/TOOLS/random_channel.c b/openair1/SIMULATION/TOOLS/random_channel.c index 05995bf1f43058f84e761f1362b579d794562743..8f3cc7c8bd697b53cd7274035ddff65e41709089 100644 --- a/openair1/SIMULATION/TOOLS/random_channel.c +++ b/openair1/SIMULATION/TOOLS/random_channel.c @@ -1,5 +1,5 @@ /******************************************************************************* - OpenAirInterface + OpenAirInterface Copyright(c) 1999 - 2014 Eurecom OpenAirInterface is free software: you can redistribute it and/or modify @@ -14,15 +14,15 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with OpenAirInterface.The full GNU General Public License is - included in this distribution in the file called "COPYING". If not, + along with OpenAirInterface.The full GNU General Public License is + included in this distribution in the file called "COPYING". If not, see <http://www.gnu.org/licenses/>. Contact Information OpenAirInterface Admin: openair_admin@eurecom.fr OpenAirInterface Tech : openair_tech@eurecom.fr OpenAirInterface Dev : openair4g-devel@eurecom.fr - + Address : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE *******************************************************************************/ @@ -82,28 +82,28 @@ void fill_channel_desc(channel_desc_t *chan_desc, } else chan_desc->delays = delays; - chan_desc->Td = Td; + chan_desc->Td = Td; chan_desc->sampling_rate = sampling_rate; chan_desc->channel_bandwidth = channel_bandwidth; - chan_desc->ricean_factor = ricean_factor; - chan_desc->aoa = aoa; - chan_desc->random_aoa = random_aoa; - chan_desc->forgetting_factor = forgetting_factor; - chan_desc->channel_offset = channel_offset; - chan_desc->path_loss_dB = path_loss_dB; - chan_desc->first_run = 1; - chan_desc->ip = 0.0; - chan_desc->max_Doppler = max_Doppler; - chan_desc->ch = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*)); - chan_desc->chF = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*)); - chan_desc->a = (struct complex**) malloc(nb_taps*sizeof(struct complex*)); + chan_desc->ricean_factor = ricean_factor; + chan_desc->aoa = aoa; + chan_desc->random_aoa = random_aoa; + chan_desc->forgetting_factor = forgetting_factor; + chan_desc->channel_offset = channel_offset; + chan_desc->path_loss_dB = path_loss_dB; + chan_desc->first_run = 1; + chan_desc->ip = 0.0; + chan_desc->max_Doppler = max_Doppler; + chan_desc->ch = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*)); + chan_desc->chF = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*)); + chan_desc->a = (struct complex**) malloc(nb_taps*sizeof(struct complex*)); LOG_D(OCM,"[CHANNEL] Filling ch \n"); - for (i = 0; i<nb_tx*nb_rx; i++) - chan_desc->ch[i] = (struct complex*) malloc(channel_length * sizeof(struct complex)); + for (i = 0; i<nb_tx*nb_rx; i++) + chan_desc->ch[i] = (struct complex*) malloc(channel_length * sizeof(struct complex)); - for (i = 0; i<nb_tx*nb_rx; i++) + for (i = 0; i<nb_tx*nb_rx; i++) chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); // allocate for up to 100 RBs, 12 samples per RB LOG_D(OCM,"[CHANNEL] Filling a (nb_taps %d)\n",nb_taps); @@ -118,8 +118,8 @@ void fill_channel_desc(channel_desc_t *chan_desc, for (i = 0; i<nb_taps; i++) { chan_desc->R_sqrt[i] = (struct complex*) calloc(nb_tx*nb_rx*nb_tx*nb_rx,sizeof(struct complex)); for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) { - chan_desc->R_sqrt[i][j].x = 1.0; - chan_desc->R_sqrt[i][j].y = 0.0; + chan_desc->R_sqrt[i][j].x = 1.0; + chan_desc->R_sqrt[i][j].y = 0.0; } } } @@ -127,9 +127,9 @@ void fill_channel_desc(channel_desc_t *chan_desc, chan_desc->R_sqrt = (struct complex**) calloc(nb_taps,sizeof(struct complex*)); for (i = 0; i<nb_taps; i++) { chan_desc->R_sqrt[i] = (struct complex*) calloc(nb_tx*nb_rx*nb_tx*nb_rx,sizeof(struct complex)); - //chan_desc->R_sqrt = (struct complex*)&R_sqrt[i][0]; - chan_desc->R_sqrt[i] = R_sqrt[0]; - } + //chan_desc->R_sqrt = (struct complex*)&R_sqrt[i][0]; + chan_desc->R_sqrt[i] = R_sqrt[0]; + } } for (i = 0; i<nb_taps; i++) { @@ -172,36 +172,36 @@ double default_amp_lin[] = {1}; double ts_shift_delays[] = {0, 1/7.68}; double ts_shift_amps[] = {0, 1}; -//correlation matrix for a 2x2 channel with full Tx correlation -struct complex R_sqrt_22_corr_tap[16] = {{0.70711,0}, {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, - {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, {0.70711,0}, - {0.70711,0}, {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, - {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, {0.70711,0}}; +//correlation matrix for a 2x2 channel with full Tx correlation +struct complex R_sqrt_22_corr_tap[16] = {{0.70711,0}, {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, + {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, {0.70711,0}, + {0.70711,0}, {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, + {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, {0.70711,0}}; struct complex *R_sqrt_22_corr[1] = {R_sqrt_22_corr_tap}; //correlation matrix for a fully correlated 2x1 channel (h1==h2) -struct complex R_sqrt_21_corr_tap[4] = {{0.70711,0}, {0.70711,0}, {0.70711,0}, {0.70711,0}}; +struct complex R_sqrt_21_corr_tap[4] = {{0.70711,0}, {0.70711,0}, {0.70711,0}, {0.70711,0}}; struct complex *R_sqrt_21_corr[1] = {R_sqrt_21_corr_tap}; -//correlation matrix for a 2x2 channel with full Tx anti-correlation -struct complex R_sqrt_22_anticorr_tap[16] = {{0.70711,0}, {0.0, 0.0}, {-0.70711,0}, {0.0, 0.0}, - {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, {-0.70711,0}, - {-0.70711,0}, {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, - {0.0, 0.0}, {-0.70711,0}, {0.0, 0.0}, {0.70711,0}}; +//correlation matrix for a 2x2 channel with full Tx anti-correlation +struct complex R_sqrt_22_anticorr_tap[16] = {{0.70711,0}, {0.0, 0.0}, {-0.70711,0}, {0.0, 0.0}, + {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, {-0.70711,0}, + {-0.70711,0}, {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, + {0.0, 0.0}, {-0.70711,0}, {0.0, 0.0}, {0.70711,0}}; struct complex *R_sqrt_22_anticorr[1] = {R_sqrt_22_anticorr_tap}; //correlation matrix for a fully anti-correlated 2x1 channel (h1==-h2) -struct complex R_sqrt_21_anticorr_tap[4] = {{0.70711,0}, {-0.70711,0}, {-0.70711,0}, {0.70711,0}}; +struct complex R_sqrt_21_anticorr_tap[4] = {{0.70711,0}, {-0.70711,0}, {-0.70711,0}, {0.70711,0}}; struct complex *R_sqrt_21_anticorr[1] = {R_sqrt_21_anticorr_tap}; struct complex **R_sqrt_ptr2; // full correlation matrix in vectorized form for 2x2 channel, where h1 is perfectly orthogonal to h2 -struct complex R_sqrt_22_orthogonal_tap[16] = {{0.70711,0.0}, {0.0, 0.0}, {0.0,0.0}, {0.0, 0.0}, - {0.0, 0.0}, {0.0,0.0}, {0.0, 0.0}, {0.0,0.0}, - {0.0,0.0}, {0.0, 0.0}, {0.0,0.0}, {0.0, 0.0}, - {0.0, 0.0}, {0.0,0.0}, {0.0, 0.0}, {0.70711,0.0}}; +struct complex R_sqrt_22_orthogonal_tap[16] = {{0.70711,0.0}, {0.0, 0.0}, {0.0,0.0}, {0.0, 0.0}, + {0.0, 0.0}, {0.0,0.0}, {0.0, 0.0}, {0.0,0.0}, + {0.0,0.0}, {0.0, 0.0}, {0.0,0.0}, {0.0, 0.0}, + {0.0, 0.0}, {0.0,0.0}, {0.0, 0.0}, {0.70711,0.0}}; struct complex *R_sqrt_22_orthogonal[1] = {R_sqrt_22_orthogonal_tap}; // full correlation matrix for TM4 to make orthogonal effective channel @@ -209,19 +209,19 @@ struct complex *R_sqrt_22_orthogonal[1] = {R_sqrt_22_orthogonal_tap}; -struct complex R_sqrt_22_orth_eff_ch_TM4_prec_real_tap[16] = {{0.70711,0.0}, {0.0, 0.0}, {0.70711,0.0}, {0.0, 0.0}, - {0.0, 0.0}, {0.70711,0.0}, {0.0, 0.0}, {-0.70711,0.0}, - {0.70711,0.0}, {0.0, 0.0}, {0.70711,0.0}, {0.0, 0.0}, - {0.0, 0.0}, {-0.70711,0.0}, {0.0, 0.0}, {0.70711,0.0}}; +struct complex R_sqrt_22_orth_eff_ch_TM4_prec_real_tap[16] = {{0.70711,0.0}, {0.0, 0.0}, {0.70711,0.0}, {0.0, 0.0}, + {0.0, 0.0}, {0.70711,0.0}, {0.0, 0.0}, {-0.70711,0.0}, + {0.70711,0.0}, {0.0, 0.0}, {0.70711,0.0}, {0.0, 0.0}, + {0.0, 0.0}, {-0.70711,0.0}, {0.0, 0.0}, {0.70711,0.0}}; struct complex *R_sqrt_22_orth_eff_ch_TM4_prec_real[1] = {R_sqrt_22_orth_eff_ch_TM4_prec_real_tap}; -struct complex R_sqrt_22_orth_eff_ch_TM4_prec_imag_tap[16] = {{0.70711,0.0}, {0.0,0.0}, {0.0, -0.70711}, {0.0,0.0}, - {0.0, 0.0}, {0.70711,0.0}, {0.0, 0.0}, {0.0,0.70711}, - {0.0,-0.70711}, {0.0, 0.0}, {-0.70711,0.0}, {0.0, 0.0}, - {0.0, 0.0}, {0.0,0.70711}, {0.0, 0.0}, {-0.70711,0.0}}; +struct complex R_sqrt_22_orth_eff_ch_TM4_prec_imag_tap[16] = {{0.70711,0.0}, {0.0,0.0}, {0.0, -0.70711}, {0.0,0.0}, + {0.0, 0.0}, {0.70711,0.0}, {0.0, 0.0}, {0.0,0.70711}, + {0.0,-0.70711}, {0.0, 0.0}, {-0.70711,0.0}, {0.0, 0.0}, + {0.0, 0.0}, {0.0,0.70711}, {0.0, 0.0}, {-0.70711,0.0}}; struct complex *R_sqrt_22_orth_eff_ch_TM4_prec_imag[1] = {R_sqrt_22_orth_eff_ch_TM4_prec_imag_tap}; @@ -232,7 +232,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, uint8_t nb_rx, SCM_t channel_model, double sampling_rate, - double channel_bandwidth, + double channel_bandwidth, double forgetting_factor, int32_t channel_offset, double path_loss_dB) @@ -244,15 +244,15 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, double aoa,ricean_factor,Td,maxDoppler; int channel_length,nb_taps; - chan_desc->nb_tx = nb_tx; - chan_desc->nb_rx = nb_rx; + chan_desc->nb_tx = nb_tx; + chan_desc->nb_rx = nb_rx; chan_desc->sampling_rate = sampling_rate; chan_desc->channel_bandwidth = channel_bandwidth; - chan_desc->forgetting_factor = forgetting_factor; - chan_desc->channel_offset = channel_offset; - chan_desc->path_loss_dB = path_loss_dB; - chan_desc->first_run = 1; - chan_desc->ip = 0.0; + chan_desc->forgetting_factor = forgetting_factor; + chan_desc->channel_offset = channel_offset; + chan_desc->path_loss_dB = path_loss_dB; + chan_desc->first_run = 1; + chan_desc->ip = 0.0; LOG_I(OCM,"Channel Model (inside of new_channel_desc_scm)=%d\n\n", channel_model); @@ -272,7 +272,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, sum_amps = 0; chan_desc->amps = (double*) malloc(chan_desc->nb_taps*sizeof(double)); for (i = 0; i<chan_desc->nb_taps; i++) { - chan_desc->amps[i] = pow(10,.1*scm_c_amps_dB[i]); + chan_desc->amps[i] = pow(10,.1*scm_c_amps_dB[i]); sum_amps += chan_desc->amps[i]; } for (i = 0; i<chan_desc->nb_taps; i++) @@ -284,34 +284,34 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, chan_desc->ch = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*)); chan_desc->chF = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*)); chan_desc->a = (struct complex**) malloc(chan_desc->nb_taps*sizeof(struct complex*)); - for (i = 0; i<nb_tx*nb_rx; i++) - chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); - for (i = 0; i<nb_tx*nb_rx; i++) - chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); - for (i = 0; i<chan_desc->nb_taps; i++) + for (i = 0; i<nb_tx*nb_rx; i++) + chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); + for (i = 0; i<nb_tx*nb_rx; i++) + chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); + for (i = 0; i<chan_desc->nb_taps; i++) chan_desc->a[i] = (struct complex*) malloc(nb_tx*nb_rx * sizeof(struct complex)); chan_desc->R_sqrt = (struct complex**) malloc(6*sizeof(struct complex**)); if (nb_tx==2 && nb_rx==2) { - for (i = 0; i<6; i++) - chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0]; + for (i = 0; i<6; i++) + chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0]; } else if (nb_tx==2 && nb_rx==1) { - for (i = 0; i<6; i++) - chan_desc->R_sqrt[i] = (struct complex*) &R21_sqrt[i][0]; + for (i = 0; i<6; i++) + chan_desc->R_sqrt[i] = (struct complex*) &R21_sqrt[i][0]; } else if (nb_tx==1 && nb_rx==2) { - for (i = 0; i<6; i++) - chan_desc->R_sqrt[i] = (struct complex*) &R12_sqrt[i][0]; + for (i = 0; i<6; i++) + chan_desc->R_sqrt[i] = (struct complex*) &R12_sqrt[i][0]; } else { for (i = 0; i<6; i++) { - chan_desc->R_sqrt[i] = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex)); - for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) { - chan_desc->R_sqrt[i][j].x = 1.0; - chan_desc->R_sqrt[i][j].y = 0.0; - } - LOG_W(OCM,"correlation matrix not implemented for nb_tx==%d and nb_rx==%d, using identity\n", nb_tx, nb_rx); + chan_desc->R_sqrt[i] = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex)); + for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) { + chan_desc->R_sqrt[i][j].x = 1.0; + chan_desc->R_sqrt[i][j].y = 0.0; + } + LOG_W(OCM,"correlation matrix not implemented for nb_tx==%d and nb_rx==%d, using identity\n", nb_tx, nb_rx); } } break; @@ -323,7 +323,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, sum_amps = 0; chan_desc->amps = (double*) malloc(chan_desc->nb_taps*sizeof(double)); for (i = 0; i<chan_desc->nb_taps; i++) { - chan_desc->amps[i] = pow(10,.1*scm_c_amps_dB[i]); + chan_desc->amps[i] = pow(10,.1*scm_c_amps_dB[i]); sum_amps += chan_desc->amps[i]; } for (i = 0; i<chan_desc->nb_taps; i++) @@ -335,34 +335,34 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, chan_desc->ch = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*)); chan_desc->chF = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*)); chan_desc->a = (struct complex**) malloc(chan_desc->nb_taps*sizeof(struct complex*)); - for (i = 0; i<nb_tx*nb_rx; i++) - chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); - for (i = 0; i<nb_tx*nb_rx; i++) - chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); - for (i = 0; i<chan_desc->nb_taps; i++) + for (i = 0; i<nb_tx*nb_rx; i++) + chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); + for (i = 0; i<nb_tx*nb_rx; i++) + chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); + for (i = 0; i<chan_desc->nb_taps; i++) chan_desc->a[i] = (struct complex*) malloc(nb_tx*nb_rx * sizeof(struct complex)); chan_desc->R_sqrt = (struct complex**) malloc(6*sizeof(struct complex**)); if (nb_tx==2 && nb_rx==2) { - for (i = 0; i<6; i++) - chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0]; + for (i = 0; i<6; i++) + chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0]; } else if (nb_tx==2 && nb_rx==1) { - for (i = 0; i<6; i++) - chan_desc->R_sqrt[i] = (struct complex*) &R21_sqrt[i][0]; + for (i = 0; i<6; i++) + chan_desc->R_sqrt[i] = (struct complex*) &R21_sqrt[i][0]; } else if (nb_tx==1 && nb_rx==2) { - for (i = 0; i<6; i++) - chan_desc->R_sqrt[i] = (struct complex*) &R12_sqrt[i][0]; + for (i = 0; i<6; i++) + chan_desc->R_sqrt[i] = (struct complex*) &R12_sqrt[i][0]; } else { for (i = 0; i<6; i++) { - chan_desc->R_sqrt[i] = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex)); - for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) { - chan_desc->R_sqrt[i][j].x = 1.0; - chan_desc->R_sqrt[i][j].y = 0.0; - } - LOG_W(OCM,"correlation matrix not implemented for nb_tx==%d and nb_rx==%d, using identity\n", nb_tx, nb_rx); + chan_desc->R_sqrt[i] = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex)); + for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) { + chan_desc->R_sqrt[i][j].x = 1.0; + chan_desc->R_sqrt[i][j].y = 0.0; + } + LOG_W(OCM,"correlation matrix not implemented for nb_tx==%d and nb_rx==%d, using identity\n", nb_tx, nb_rx); } } break; @@ -373,7 +373,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, sum_amps = 0; chan_desc->amps = (double*) malloc(chan_desc->nb_taps*sizeof(double)); for (i = 0; i<chan_desc->nb_taps; i++) { - chan_desc->amps[i] = pow(10,.1*epa_amps_dB[i]); + chan_desc->amps[i] = pow(10,.1*epa_amps_dB[i]); sum_amps += chan_desc->amps[i]; } for (i = 0; i<chan_desc->nb_taps; i++) @@ -385,26 +385,26 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, chan_desc->ch = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*)); chan_desc->chF = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*)); chan_desc->a = (struct complex**) malloc(chan_desc->nb_taps*sizeof(struct complex*)); - for (i = 0; i<nb_tx*nb_rx; i++) - chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); - for (i = 0; i<nb_tx*nb_rx; i++) - chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); - for (i = 0; i<chan_desc->nb_taps; i++) + for (i = 0; i<nb_tx*nb_rx; i++) + chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); + for (i = 0; i<nb_tx*nb_rx; i++) + chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); + for (i = 0; i<chan_desc->nb_taps; i++) chan_desc->a[i] = (struct complex*) malloc(nb_tx*nb_rx * sizeof(struct complex)); if (nb_tx==2 && nb_rx==2) { chan_desc->R_sqrt = (struct complex**) malloc(6*sizeof(struct complex**)); - for (i = 0; i<6; i++) - chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0]; + for (i = 0; i<6; i++) + chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0]; } else { chan_desc->R_sqrt = (struct complex**) malloc(6*sizeof(struct complex**)); for (i = 0; i<6; i++) { - chan_desc->R_sqrt[i] = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex)); - for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) { - chan_desc->R_sqrt[i][j].x = 1.0; - chan_desc->R_sqrt[i][j].y = 0.0; - } - LOG_W(OCM,"correlation matrix only implemented for nb_tx==2 and nb_rx==2, using identity\n"); + chan_desc->R_sqrt[i] = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex)); + for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) { + chan_desc->R_sqrt[i][j].x = 1.0; + chan_desc->R_sqrt[i][j].y = 0.0; + } + LOG_W(OCM,"correlation matrix only implemented for nb_tx==2 and nb_rx==2, using identity\n"); } } break; @@ -415,7 +415,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, sum_amps = 0; chan_desc->amps = (double*) malloc(chan_desc->nb_taps*sizeof(double)); for (i = 0; i<chan_desc->nb_taps; i++) { - chan_desc->amps[i] = pow(10,.1*eva_amps_dB[i]); + chan_desc->amps[i] = pow(10,.1*eva_amps_dB[i]); sum_amps += chan_desc->amps[i]; } for (i = 0; i<chan_desc->nb_taps; i++) @@ -427,26 +427,26 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, chan_desc->ch = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*)); chan_desc->chF = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*)); chan_desc->a = (struct complex**) malloc(chan_desc->nb_taps*sizeof(struct complex*)); - for (i = 0; i<nb_tx*nb_rx; i++) - chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); - for (i = 0; i<nb_tx*nb_rx; i++) - chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); - for (i = 0; i<chan_desc->nb_taps; i++) + for (i = 0; i<nb_tx*nb_rx; i++) + chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); + for (i = 0; i<nb_tx*nb_rx; i++) + chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); + for (i = 0; i<chan_desc->nb_taps; i++) chan_desc->a[i] = (struct complex*) malloc(nb_tx*nb_rx * sizeof(struct complex)); if (nb_tx==2 && nb_rx==2) { chan_desc->R_sqrt = (struct complex**) malloc(6*sizeof(struct complex**)); - for (i = 0; i<6; i++) - chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0]; + for (i = 0; i<6; i++) + chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0]; } else { chan_desc->R_sqrt = (struct complex**) malloc(6*sizeof(struct complex**)); for (i = 0; i<6; i++) { - chan_desc->R_sqrt[i] = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex)); - for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) { - chan_desc->R_sqrt[i][j].x = 1.0; - chan_desc->R_sqrt[i][j].y = 0.0; - } - LOG_W(OCM,"correlation matrix only implemented for nb_tx==2 and nb_rx==2, using identity\n"); + chan_desc->R_sqrt[i] = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex)); + for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) { + chan_desc->R_sqrt[i][j].x = 1.0; + chan_desc->R_sqrt[i][j].y = 0.0; + } + LOG_W(OCM,"correlation matrix only implemented for nb_tx==2 and nb_rx==2, using identity\n"); } } break; @@ -457,7 +457,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, sum_amps = 0; chan_desc->amps = (double*) malloc(chan_desc->nb_taps*sizeof(double)); for (i = 0; i<chan_desc->nb_taps; i++) { - chan_desc->amps[i] = pow(10,.1*etu_amps_dB[i]); + chan_desc->amps[i] = pow(10,.1*etu_amps_dB[i]); sum_amps += chan_desc->amps[i]; } for (i = 0; i<chan_desc->nb_taps; i++) @@ -469,26 +469,26 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, chan_desc->ch = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*)); chan_desc->chF = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*)); chan_desc->a = (struct complex**) malloc(chan_desc->nb_taps*sizeof(struct complex*)); - for (i = 0; i<nb_tx*nb_rx; i++) - chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); - for (i = 0; i<nb_tx*nb_rx; i++) - chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); - for (i = 0; i<chan_desc->nb_taps; i++) + for (i = 0; i<nb_tx*nb_rx; i++) + chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); + for (i = 0; i<nb_tx*nb_rx; i++) + chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); + for (i = 0; i<chan_desc->nb_taps; i++) chan_desc->a[i] = (struct complex*) malloc(nb_tx*nb_rx * sizeof(struct complex)); if (nb_tx==2 && nb_rx==2) { chan_desc->R_sqrt = (struct complex**) malloc(6*sizeof(struct complex**)); - for (i = 0; i<6; i++) - chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0]; + for (i = 0; i<6; i++) + chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0]; } else { chan_desc->R_sqrt = (struct complex**) malloc(6*sizeof(struct complex**)); for (i = 0; i<6; i++) { - chan_desc->R_sqrt[i] = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex)); - for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) { - chan_desc->R_sqrt[i][j].x = 1.0; - chan_desc->R_sqrt[i][j].y = 0.0; - } - LOG_W(OCM,"correlation matrix only implemented for nb_tx==2 and nb_rx==2, using identity\n"); + chan_desc->R_sqrt[i] = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex)); + for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) { + chan_desc->R_sqrt[i][j].x = 1.0; + chan_desc->R_sqrt[i][j].y = 0.0; + } + LOG_W(OCM,"correlation matrix only implemented for nb_tx==2 and nb_rx==2, using identity\n"); } } break; @@ -499,7 +499,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, sum_amps = 0; chan_desc->amps = (double*) malloc(chan_desc->nb_taps*sizeof(double)); for (i = 0; i<chan_desc->nb_taps; i++) { - chan_desc->amps[i] = pow(10,.1*mbsfn_amps_dB[i]); + chan_desc->amps[i] = pow(10,.1*mbsfn_amps_dB[i]); sum_amps += chan_desc->amps[i]; } for (i = 0; i<chan_desc->nb_taps; i++) @@ -511,19 +511,19 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, chan_desc->ch = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*)); chan_desc->chF = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*)); chan_desc->a = (struct complex**) malloc(chan_desc->nb_taps*sizeof(struct complex*)); - for (i = 0; i<nb_tx*nb_rx; i++) - chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); - for (i = 0; i<nb_tx*nb_rx; i++) - chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); - for (i = 0; i<chan_desc->nb_taps; i++) + for (i = 0; i<nb_tx*nb_rx; i++) + chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); + for (i = 0; i<nb_tx*nb_rx; i++) + chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); + for (i = 0; i<chan_desc->nb_taps; i++) chan_desc->a[i] = (struct complex*) malloc(nb_tx*nb_rx * sizeof(struct complex)); chan_desc->R_sqrt = (struct complex**) malloc(6*sizeof(struct complex*)); for (i = 0; i<6; i++) { chan_desc->R_sqrt[i] = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex)); for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) { - chan_desc->R_sqrt[i][j].x = 1.0; - chan_desc->R_sqrt[i][j].y = 0.0; + chan_desc->R_sqrt[i][j].x = 1.0; + chan_desc->R_sqrt[i][j].y = 0.0; } LOG_W(OCM,"correlation matrix only implemented for nb_tx==2 and nb_rx==2, using identity\n"); } @@ -538,23 +538,23 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, maxDoppler = 0; fill_channel_desc(chan_desc, - nb_tx, - nb_rx, - nb_taps, - channel_length, - default_amps_lin, - NULL, - NULL, - Td, - sampling_rate, - channel_bandwidth, - ricean_factor, - aoa, - forgetting_factor, - maxDoppler, - channel_offset, - path_loss_dB, - 0); + nb_tx, + nb_rx, + nb_taps, + channel_length, + default_amps_lin, + NULL, + NULL, + Td, + sampling_rate, + channel_bandwidth, + ricean_factor, + aoa, + forgetting_factor, + maxDoppler, + channel_offset, + path_loss_dB, + 0); break; case Rice8: @@ -566,22 +566,22 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, maxDoppler = 0; fill_channel_desc(chan_desc,nb_tx, - nb_rx, - nb_taps, - channel_length, - default_amps_lin, - NULL, - NULL, - Td, - sampling_rate, - channel_bandwidth, - ricean_factor, - aoa, - forgetting_factor, - maxDoppler, - channel_offset, - path_loss_dB, - 1); + nb_rx, + nb_taps, + channel_length, + default_amps_lin, + NULL, + NULL, + Td, + sampling_rate, + channel_bandwidth, + ricean_factor, + aoa, + forgetting_factor, + maxDoppler, + channel_offset, + path_loss_dB, + 1); break; case Rayleigh1: @@ -593,22 +593,22 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, maxDoppler = 0; fill_channel_desc(chan_desc,nb_tx, - nb_rx, - nb_taps, - channel_length, - default_amp_lin, - NULL, - NULL, - Td, - sampling_rate, - channel_bandwidth, - ricean_factor, - aoa, - forgetting_factor, - maxDoppler, - channel_offset, - path_loss_dB, - 0); + nb_rx, + nb_taps, + channel_length, + default_amp_lin, + NULL, + NULL, + Td, + sampling_rate, + channel_bandwidth, + ricean_factor, + aoa, + forgetting_factor, + maxDoppler, + channel_offset, + path_loss_dB, + 0); break; case Rayleigh1_800: @@ -620,22 +620,22 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, maxDoppler = 800; fill_channel_desc(chan_desc,nb_tx, - nb_rx, - nb_taps, - channel_length, - default_amp_lin, - NULL, - NULL, - Td, - sampling_rate, - channel_bandwidth, - ricean_factor, - aoa, - forgetting_factor, - maxDoppler, - channel_offset, - path_loss_dB, - 0); + nb_rx, + nb_taps, + channel_length, + default_amp_lin, + NULL, + NULL, + Td, + sampling_rate, + channel_bandwidth, + ricean_factor, + aoa, + forgetting_factor, + maxDoppler, + channel_offset, + path_loss_dB, + 0); break; case Rayleigh1_corr: @@ -647,31 +647,31 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, maxDoppler = 0; if ((nb_tx==2) && (nb_rx==1)) { - R_sqrt_ptr2 = R_sqrt_21_corr; + R_sqrt_ptr2 = R_sqrt_21_corr; } else if ((nb_tx==2) && (nb_rx==2)) { - R_sqrt_ptr2 = R_sqrt_22_corr; + R_sqrt_ptr2 = R_sqrt_22_corr; } else - R_sqrt_ptr2 = NULL; + R_sqrt_ptr2 = NULL; fill_channel_desc(chan_desc,nb_tx, - nb_rx, - nb_taps, - channel_length, - default_amp_lin, - NULL, - R_sqrt_ptr2, - Td, - sampling_rate, - channel_bandwidth, - ricean_factor, - aoa, - forgetting_factor, - maxDoppler, - channel_offset, - path_loss_dB, - 0); + nb_rx, + nb_taps, + channel_length, + default_amp_lin, + NULL, + R_sqrt_ptr2, + Td, + sampling_rate, + channel_bandwidth, + ricean_factor, + aoa, + forgetting_factor, + maxDoppler, + channel_offset, + path_loss_dB, + 0); break; case Rayleigh1_anticorr: @@ -683,31 +683,31 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, maxDoppler = 0; if ((nb_tx==2) && (nb_rx==1)) { //check this - R_sqrt_ptr2 = R_sqrt_21_anticorr; + R_sqrt_ptr2 = R_sqrt_21_anticorr; } else if ((nb_tx==2) && (nb_rx==2)) { - R_sqrt_ptr2 = R_sqrt_22_anticorr; + R_sqrt_ptr2 = R_sqrt_22_anticorr; } - else - R_sqrt_ptr2 = NULL; + else + R_sqrt_ptr2 = NULL; fill_channel_desc(chan_desc,nb_tx, - nb_rx, - nb_taps, - channel_length, - default_amp_lin, - NULL, - R_sqrt_ptr2, - Td, - sampling_rate, - channel_bandwidth, - ricean_factor, - aoa, - forgetting_factor, - maxDoppler, - channel_offset, - path_loss_dB, - 0); + nb_rx, + nb_taps, + channel_length, + default_amp_lin, + NULL, + R_sqrt_ptr2, + Td, + sampling_rate, + channel_bandwidth, + ricean_factor, + aoa, + forgetting_factor, + maxDoppler, + channel_offset, + path_loss_dB, + 0); break; case Rice1: @@ -719,22 +719,22 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, maxDoppler = 0; fill_channel_desc(chan_desc,nb_tx, - nb_rx, - nb_taps, - channel_length, - default_amp_lin, - NULL, - NULL, - Td, - sampling_rate, - channel_bandwidth, - ricean_factor, - aoa, - forgetting_factor, - maxDoppler, - channel_offset, - path_loss_dB, - 0); + nb_rx, + nb_taps, + channel_length, + default_amp_lin, + NULL, + NULL, + Td, + sampling_rate, + channel_bandwidth, + ricean_factor, + aoa, + forgetting_factor, + maxDoppler, + channel_offset, + path_loss_dB, + 0); break; case AWGN: @@ -746,22 +746,22 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, maxDoppler = 0; fill_channel_desc(chan_desc,nb_tx, - nb_rx, - nb_taps, - channel_length, - default_amp_lin, - NULL, - NULL, - Td, - sampling_rate, - channel_bandwidth, - ricean_factor, - aoa, - forgetting_factor, - maxDoppler, - channel_offset, - path_loss_dB, - 0); + nb_rx, + nb_taps, + channel_length, + default_amp_lin, + NULL, + NULL, + Td, + sampling_rate, + channel_bandwidth, + ricean_factor, + aoa, + forgetting_factor, + maxDoppler, + channel_offset, + path_loss_dB, + 0); printf("AWGN: ricean_factor %f\n",chan_desc->ricean_factor); break; @@ -775,22 +775,22 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, maxDoppler = 0; fill_channel_desc(chan_desc,nb_tx, - nb_rx, - nb_taps, - channel_length, - ts_shift_amps, - ts_shift_delays, - NULL, - Td, - sampling_rate, - channel_bandwidth, - ricean_factor, - aoa, - forgetting_factor, - maxDoppler, - channel_offset, - path_loss_dB, - 0); + nb_rx, + nb_taps, + channel_length, + ts_shift_amps, + ts_shift_delays, + NULL, + Td, + sampling_rate, + channel_bandwidth, + ricean_factor, + aoa, + forgetting_factor, + maxDoppler, + channel_offset, + path_loss_dB, + 0); printf("TS_SHIFT: ricean_factor %f\n",chan_desc->ricean_factor); break; @@ -804,31 +804,31 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, maxDoppler = 0; if ((nb_tx==2) && (nb_rx==1)) { - R_sqrt_ptr2 = R_sqrt_21_corr; + R_sqrt_ptr2 = R_sqrt_21_corr; } else if ((nb_tx==2) && (nb_rx==2)) { - R_sqrt_ptr2 = R_sqrt_22_corr; + R_sqrt_ptr2 = R_sqrt_22_corr; } else - R_sqrt_ptr2 = NULL; + R_sqrt_ptr2 = NULL; fill_channel_desc(chan_desc,nb_tx, - nb_rx, - nb_taps, - channel_length, - default_amp_lin, - NULL, - R_sqrt_ptr2, - Td, - sampling_rate, - channel_bandwidth, - ricean_factor, - aoa, - forgetting_factor, - maxDoppler, - channel_offset, - path_loss_dB, - 1); + nb_rx, + nb_taps, + channel_length, + default_amp_lin, + NULL, + R_sqrt_ptr2, + Td, + sampling_rate, + channel_bandwidth, + ricean_factor, + aoa, + forgetting_factor, + maxDoppler, + channel_offset, + path_loss_dB, + 1); break; case Rice1_anticorr: @@ -840,33 +840,33 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, maxDoppler = 0; if ((nb_tx==2) && (nb_rx==1)) { - R_sqrt_ptr2 = R_sqrt_21_anticorr; + R_sqrt_ptr2 = R_sqrt_21_anticorr; } else if ((nb_tx==2) && (nb_rx==2)) { - R_sqrt_ptr2 = R_sqrt_22_anticorr; + R_sqrt_ptr2 = R_sqrt_22_anticorr; } - else - R_sqrt_ptr2 = NULL; + else + R_sqrt_ptr2 = NULL; fill_channel_desc(chan_desc,nb_tx, - nb_rx, - nb_taps, - channel_length, - default_amp_lin, - NULL, - R_sqrt_ptr2, - Td, - sampling_rate, - channel_bandwidth, - ricean_factor, - aoa, - forgetting_factor, - maxDoppler, - channel_offset, - path_loss_dB, - 1); + nb_rx, + nb_taps, + channel_length, + default_amp_lin, + NULL, + R_sqrt_ptr2, + Td, + sampling_rate, + channel_bandwidth, + ricean_factor, + aoa, + forgetting_factor, + maxDoppler, + channel_offset, + path_loss_dB, + 1); break; - + case Rayleigh1_orthogonal: nb_taps = 1; Td = 0; @@ -875,32 +875,32 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, aoa = 0.03; maxDoppler = 0; - + if ((nb_tx==2) && (nb_rx==2)) { - R_sqrt_ptr2 = R_sqrt_22_orthogonal; + R_sqrt_ptr2 = R_sqrt_22_orthogonal; } - else - R_sqrt_ptr2 = NULL; + else + R_sqrt_ptr2 = NULL; fill_channel_desc(chan_desc,nb_tx, - nb_rx, - nb_taps, - channel_length, - default_amp_lin, - NULL, - R_sqrt_ptr2, - Td, - sampling_rate, - channel_bandwidth, - ricean_factor, - aoa, - forgetting_factor, - maxDoppler, - channel_offset, - path_loss_dB, - 0); + nb_rx, + nb_taps, + channel_length, + default_amp_lin, + NULL, + R_sqrt_ptr2, + Td, + sampling_rate, + channel_bandwidth, + ricean_factor, + aoa, + forgetting_factor, + maxDoppler, + channel_offset, + path_loss_dB, + 0); break; - + case Rayleigh1_orth_eff_ch_TM4_prec_real: nb_taps = 1; Td = 0; @@ -909,32 +909,32 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, aoa = 0.03; maxDoppler = 0; - + if ((nb_tx==2) && (nb_rx==2)) { - R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_real; + R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_real; } - else - R_sqrt_ptr2 = NULL; + else + R_sqrt_ptr2 = NULL; fill_channel_desc(chan_desc,nb_tx, - nb_rx, - nb_taps, - channel_length, - default_amp_lin, - NULL, - R_sqrt_ptr2, - Td, - sampling_rate, - channel_bandwidth, - ricean_factor, - aoa, - forgetting_factor, - maxDoppler, - channel_offset, - path_loss_dB, - 1); + nb_rx, + nb_taps, + channel_length, + default_amp_lin, + NULL, + R_sqrt_ptr2, + Td, + sampling_rate, + channel_bandwidth, + ricean_factor, + aoa, + forgetting_factor, + maxDoppler, + channel_offset, + path_loss_dB, + 1); break; - + case Rayleigh1_orth_eff_ch_TM4_prec_imag: nb_taps = 1; Td = 0; @@ -943,42 +943,42 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, aoa = 0.03; maxDoppler = 0; - + if ((nb_tx==2) && (nb_rx==2)) { - R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_imag; + R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_imag; } - else - R_sqrt_ptr2 = NULL; + else + R_sqrt_ptr2 = NULL; fill_channel_desc(chan_desc,nb_tx, - nb_rx, - nb_taps, - channel_length, - default_amp_lin, - NULL, - R_sqrt_ptr2, - Td, - sampling_rate, - channel_bandwidth, - ricean_factor, - aoa, - forgetting_factor, - maxDoppler, - channel_offset, - path_loss_dB, - 0); + nb_rx, + nb_taps, + channel_length, + default_amp_lin, + NULL, + R_sqrt_ptr2, + Td, + sampling_rate, + channel_bandwidth, + ricean_factor, + aoa, + forgetting_factor, + maxDoppler, + channel_offset, + path_loss_dB, + 0); break; - + case Rayleigh8_orth_eff_ch_TM4_prec_real: if ((nb_tx==2) && (nb_rx==2)) { - R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_real; - //R_sqrt_ptr2 = NULL; + R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_real; + //R_sqrt_ptr2 = NULL; } - else - R_sqrt_ptr2 = NULL; + else + R_sqrt_ptr2 = NULL; + - nb_taps = 8; Td = 0.8; channel_length = (int)11+2*sampling_rate*Td; @@ -987,26 +987,26 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, maxDoppler = 0; fill_channel_desc(chan_desc, - nb_tx, - nb_rx, - nb_taps, - channel_length, - default_amps_lin, - NULL, - R_sqrt_ptr2, - Td, - sampling_rate, - channel_bandwidth, - ricean_factor, - aoa, - forgetting_factor, - maxDoppler, - channel_offset, - path_loss_dB, - 0); - + nb_tx, + nb_rx, + nb_taps, + channel_length, + default_amps_lin, + NULL, + R_sqrt_ptr2, + Td, + sampling_rate, + channel_bandwidth, + ricean_factor, + aoa, + forgetting_factor, + maxDoppler, + channel_offset, + path_loss_dB, + 0); + break; - + case Rayleigh8_orth_eff_ch_TM4_prec_imag: nb_taps = 8; Td = 0.8; @@ -1016,31 +1016,31 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, maxDoppler = 0; if ((nb_tx==2) && (nb_rx==2)) { - R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_imag; + R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_imag; } - else - R_sqrt_ptr2 = NULL; + else + R_sqrt_ptr2 = NULL; fill_channel_desc(chan_desc, - nb_tx, - nb_rx, - nb_taps, - channel_length, - default_amps_lin, - NULL, - R_sqrt_ptr2, - Td, - sampling_rate, - channel_bandwidth, - ricean_factor, - aoa, - forgetting_factor, - maxDoppler, - channel_offset, - path_loss_dB, - 0); + nb_tx, + nb_rx, + nb_taps, + channel_length, + default_amps_lin, + NULL, + R_sqrt_ptr2, + Td, + sampling_rate, + channel_bandwidth, + ricean_factor, + aoa, + forgetting_factor, + maxDoppler, + channel_offset, + path_loss_dB, + 0); break; - + default: LOG_W(OCM,"channel model not yet supported\n"); free(chan_desc); @@ -1057,12 +1057,12 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) { - + double s; int i,k,l,aarx,aatx; struct complex anew[NB_ANTENNAS_TX*NB_ANTENNAS_RX],acorr[NB_ANTENNAS_TX*NB_ANTENNAS_RX]; struct complex phase, alpha, beta; - + if ((desc->nb_tx>NB_ANTENNAS_TX) || (desc->nb_rx > NB_ANTENNAS_RX)) { msg("random_channel.c: Error: temporary buffer for channel not big enough (%d,%d)\n",desc->nb_tx,desc->nb_rx); return(-1); @@ -1073,26 +1073,26 @@ int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) { for (aarx=0;aarx<desc->nb_rx;aarx++) { for (aatx=0;aatx<desc->nb_tx;aatx++) { - anew[aarx+(aatx*desc->nb_rx)].x = sqrt(desc->ricean_factor*desc->amps[i]/2) * gaussdouble(0.0,1.0); - anew[aarx+(aatx*desc->nb_rx)].y = sqrt(desc->ricean_factor*desc->amps[i]/2) * gaussdouble(0.0,1.0); - - if ((i==0) && (desc->ricean_factor != 1.0)) { - if (desc->random_aoa==1) { - desc->aoa = uniformrandom()*2*M_PI; - } - - // this assumes that both RX and TX have linear antenna arrays with lambda/2 antenna spacing. - // Furhter it is assumed that the arrays are parallel to each other and that they are far enough apart so - // that we can safely assume plane wave propagation. - phase.x = cos(M_PI*((aarx-aatx)*sin(desc->aoa))); - phase.y = sin(M_PI*((aarx-aatx)*sin(desc->aoa))); - - anew[aarx+(aatx*desc->nb_rx)].x += phase.x * sqrt(1.0-desc->ricean_factor); - anew[aarx+(aatx*desc->nb_rx)].y += phase.y * sqrt(1.0-desc->ricean_factor); - } + anew[aarx+(aatx*desc->nb_rx)].x = sqrt(desc->ricean_factor*desc->amps[i]/2) * gaussdouble(0.0,1.0); + anew[aarx+(aatx*desc->nb_rx)].y = sqrt(desc->ricean_factor*desc->amps[i]/2) * gaussdouble(0.0,1.0); + + if ((i==0) && (desc->ricean_factor != 1.0)) { + if (desc->random_aoa==1) { + desc->aoa = uniformrandom()*2*M_PI; + } + + // this assumes that both RX and TX have linear antenna arrays with lambda/2 antenna spacing. + // Furhter it is assumed that the arrays are parallel to each other and that they are far enough apart so + // that we can safely assume plane wave propagation. + phase.x = cos(M_PI*((aarx-aatx)*sin(desc->aoa))); + phase.y = sin(M_PI*((aarx-aatx)*sin(desc->aoa))); + + anew[aarx+(aatx*desc->nb_rx)].x += phase.x * sqrt(1.0-desc->ricean_factor); + anew[aarx+(aatx*desc->nb_rx)].y += phase.y * sqrt(1.0-desc->ricean_factor); + } #ifdef DEBUG_CH - printf("(%d,%d,%d) %f->(%f,%f) (%f,%f) phase (%f,%f)\n",aarx,aatx,i,desc->amps[i],anew[aarx+(aatx*desc->nb_rx)].x,anew[aarx+(aatx*desc->nb_rx)].y,desc->aoa,desc->ricean_factor,phase.x,phase.y); -#endif + printf("(%d,%d,%d) %f->(%f,%f) (%f,%f) phase (%f,%f)\n",aarx,aatx,i,desc->amps[i],anew[aarx+(aatx*desc->nb_rx)].x,anew[aarx+(aatx*desc->nb_rx)].y,desc->aoa,desc->ricean_factor,phase.x,phase.y); +#endif } //aatx } //aarx @@ -1100,9 +1100,9 @@ int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) { // for debugging set a=anew; for (aarx=0;aarx<desc->nb_rx;aarx++) { for (aatx=0;aatx<desc->nb_tx;aatx++) { - desc->a[i][aarx+(aatx*desc->nb_rx)].x = anew[aarx+(aatx*desc->nb_rx)].x; - desc->a[i][aarx+(aatx*desc->nb_rx)].y = anew[aarx+(aatx*desc->nb_rx)].y; - printf("anew(%d,%d) = %f+1j*%f\n",aatx,aarx,anew[aarx+(aatx*desc->nb_rx)].x, anew[aarx+(aatx*desc->nb_rx)].y); + desc->a[i][aarx+(aatx*desc->nb_rx)].x = anew[aarx+(aatx*desc->nb_rx)].x; + desc->a[i][aarx+(aatx*desc->nb_rx)].y = anew[aarx+(aatx*desc->nb_rx)].y; + printf("anew(%d,%d) = %f+1j*%f\n",aatx,aarx,anew[aarx+(aatx*desc->nb_rx)].x, anew[aarx+(aatx*desc->nb_rx)].y); } } */ @@ -1113,16 +1113,16 @@ int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) { beta.x = 0.0; beta.y = 0.0; - cblas_zgemv(CblasRowMajor, CblasNoTrans, desc->nb_tx*desc->nb_rx, desc->nb_tx*desc->nb_rx, - (void*) &alpha, (void*) desc->R_sqrt[i/3], desc->nb_rx*desc->nb_tx, - (void*) anew, 1, (void*) &beta, (void*) acorr, 1); + cblas_zgemv(CblasRowMajor, CblasNoTrans, desc->nb_tx*desc->nb_rx, desc->nb_tx*desc->nb_rx, + (void*) &alpha, (void*) desc->R_sqrt[i/3], desc->nb_rx*desc->nb_tx, + (void*) anew, 1, (void*) &beta, (void*) acorr, 1); /* for (aarx=0;aarx<desc->nb_rx;aarx++) { for (aatx=0;aatx<desc->nb_tx;aatx++) { - desc->a[i][aarx+(aatx*desc->nb_rx)].x = acorr[aarx+(aatx*desc->nb_rx)].x; - desc->a[i][aarx+(aatx*desc->nb_rx)].y = acorr[aarx+(aatx*desc->nb_rx)].y; - printf("tap %d, acorr1(%d,%d) = %f+1j*%f\n",i,aatx,aarx,acorr[aarx+(aatx*desc->nb_rx)].x, acorr[aarx+(aatx*desc->nb_rx)].y); + desc->a[i][aarx+(aatx*desc->nb_rx)].x = acorr[aarx+(aatx*desc->nb_rx)].x; + desc->a[i][aarx+(aatx*desc->nb_rx)].y = acorr[aarx+(aatx*desc->nb_rx)].y; + printf("tap %d, acorr1(%d,%d) = %f+1j*%f\n",i,aatx,aarx,acorr[aarx+(aatx*desc->nb_rx)].x, acorr[aarx+(aatx*desc->nb_rx)].y); } } */ @@ -1148,18 +1148,18 @@ int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) { /* for (aarx=0;aarx<desc->nb_rx;aarx++) { for (aatx=0;aatx<desc->nb_tx;aatx++) { - //desc->a[i][aarx+(aatx*desc->nb_rx)].x = acorr[aarx+(aatx*desc->nb_rx)].x; - //desc->a[i][aarx+(aatx*desc->nb_rx)].y = acorr[aarx+(aatx*desc->nb_rx)].y; - printf("tap %d, a(%d,%d) = %f+1j*%f\n",i,aatx,aarx,desc->a[i][aarx+(aatx*desc->nb_rx)].x, desc->a[i][aarx+(aatx*desc->nb_rx)].y); + //desc->a[i][aarx+(aatx*desc->nb_rx)].x = acorr[aarx+(aatx*desc->nb_rx)].x; + //desc->a[i][aarx+(aatx*desc->nb_rx)].y = acorr[aarx+(aatx*desc->nb_rx)].y; + printf("tap %d, a(%d,%d) = %f+1j*%f\n",i,aatx,aarx,desc->a[i][aarx+(aatx*desc->nb_rx)].x, desc->a[i][aarx+(aatx*desc->nb_rx)].y); } } */ - } //nb_taps + } //nb_taps stop_meas(&desc->random_channel); //memset((void *)desc->ch[aarx+(aatx*desc->nb_rx)],0,(int)(desc->channel_length)*sizeof(struct complex)); - + if (abstraction_flag==0) { start_meas(&desc->interp_time); @@ -1188,10 +1188,10 @@ int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) { } //nb_taps #ifdef DEBUG_CH - k=0; - printf("(%d,%d,%d)->(%f,%f)\n",k,aarx,aatx,desc->ch[aarx+(aatx*desc->nb_rx)][k].x,desc->ch[aarx+(aatx*desc->nb_rx)][k].y); + k=0; + printf("(%d,%d,%d)->(%f,%f)\n",k,aarx,aatx,desc->ch[aarx+(aatx*desc->nb_rx)][k].x,desc->ch[aarx+(aatx*desc->nb_rx)][k].y); #endif - } + } } //channel_length } //aatx } //aarx @@ -1211,22 +1211,22 @@ double N_RB2sampling_rate(uint16_t N_RB) case 6: sampling_rate = 1.92; break; - + case 25: sampling_rate = 7.68; break; - + case 50: sampling_rate = 15.36; break; - + case 100: sampling_rate = 30.72; break; - + default: LOG_E(PHY,"Unknown N_PRB\n"); - return(-1); + return(-1); } return(sampling_rate); @@ -1239,22 +1239,22 @@ double N_RB2channel_bandwidth(uint16_t N_RB) case 6: channel_bandwidth = 1.25; break; - + case 25: channel_bandwidth = 5.00; break; - + case 50: channel_bandwidth = 10.00; break; - + case 100: channel_bandwidth = 20.00; break; - + default: LOG_E(PHY,"Unknown N_PRB\n"); - return(-1); + return(-1); } return(channel_bandwidth); } @@ -1267,7 +1267,7 @@ main(int argc,char **argv) { double amps[8] = {.8,.2,.1,.04,.02,.01,.005}; struct complex ch[(int)(1+2*sampling_rate*Td)],phase; int i; - + randominit(); phase.x = 1.0; phase.y = 0; diff --git a/openair1/SIMULATION/TOOLS/rangen_double.c b/openair1/SIMULATION/TOOLS/rangen_double.c index d7d0543faea780d7fa01d992079dc1f7bfd4d3cc..6b98bbe7a7acd0d33c2b6732bc44d8ceb2ed7c13 100644 --- a/openair1/SIMULATION/TOOLS/rangen_double.c +++ b/openair1/SIMULATION/TOOLS/rangen_double.c @@ -46,7 +46,7 @@ static unsigned int seed, iy, ir[98]; #define a 1664525lu #define mod 4294967296.0 /* is 2**32 */ - +#if 1 void randominit(unsigned seed_init) { int i; @@ -69,17 +69,18 @@ void randominit(unsigned seed_init) } iy=1; -} - +} +#endif -/*void randominit(unsigned seed_init) +#if 0 +void randominit(unsigned seed_init) { int i; // this need to be integrated with the existing rng, like taus: navid msg("Initializing random number generator, seed %x\n",seed_init); seed_init = 62110; - + if (seed_init == 0) { srand((unsigned)time(NULL)); @@ -90,14 +91,14 @@ void randominit(unsigned seed_init) if (seed % 2 == 0) seed += 1; /* seed and mod are relative prime */ -// for (i=1; i<=97; i++) { -// seed = a*seed; /* mod 2**32 */ -// ir[i]= seed; /* initialize the shuffle table */ -// } - -// iy=1; -//} + for (i=1; i<=97; i++) { + seed = a*seed; /* mod 2**32 */ + ir[i]= seed; /* initialize the shuffle table */ + } + iy=1; +} +#endif /*!\brief Uniform linear congruential random number generator on \f$[0,1)\f$. Returns a double-precision floating-point number.*/ double uniformrandom(void) diff --git a/openair1/SIMULATION/TOOLS/taus.c b/openair1/SIMULATION/TOOLS/taus.c index be2700d9430b3d910fdeee2183989e8eb0a29dd6..8ef3538867c2854016ce6847af8168d0cf9dd7c4 100644 --- a/openair1/SIMULATION/TOOLS/taus.c +++ b/openair1/SIMULATION/TOOLS/taus.c @@ -58,7 +58,7 @@ unsigned int taus(void) s2 = (((s2 & 0xFFFFFFF0) << 17)^ b); return s0 ^ s1 ^ s2; } - +#if 1 void set_taus_seed(unsigned int seed_init) { @@ -87,9 +87,11 @@ void set_taus_seed(unsigned int seed_init) s2 = result; #endif } -} - -/* void set_taus_seed(unsigned int seed_init) +} +#endif + +#if 0 + void set_taus_seed(unsigned int seed_init) { #ifdef USER_MODE @@ -113,18 +115,17 @@ void set_taus_seed(unsigned int seed_init) s2 = (unsigned int)0xfe1a133e; #else // Use reentrant version of rand48 to ensure that no conflicts with other generators occur */ - // srand48_r((long int)seed_init, &buffer); - // mrand48_r(&buffer, (long int *)&result); - // s0 = result; - // mrand48_r(&buffer, (long int *)&result); - // s1 = result; - // mrand48_r(&buffer, (long int *)&result); - // s2 = result; -//#endif - // } -//} - - + srand48_r((long int)seed_init, &buffer); + mrand48_r(&buffer, (long int *)&result); + s0 = result; + mrand48_r(&buffer, (long int *)&result); + s1 = result; + mrand48_r(&buffer, (long int *)&result); + s2 = result; +#endif + } +} +#endif #ifdef MAIN