dlsim and ulsim functional. dlsim 1-2 antenna ports, TM1/2. ulsim 1-2 antenna ports.

openair1/PHY/CODING/lte_rate_matching.c

@@ -749,6 +749,10 @@ int lte_rate_matching_turbo_rx(uint32_t RTC,
 
   for (; (ind<Ncb)&&(k<E); ind++) {
     if (dummy_w[ind] != LTE_NULL) {
+      /*
+      if ((w[ind]>0 && soft_input2[k]<0) || 
+	  (w[ind]<0 && soft_input2[k]>0))  
+	  printf("ind %d: w %d => soft_in %d\n",ind,w[ind],soft_input2[k]);*/
       w[ind] += soft_input2[k++];
 #ifdef RM_DEBUG
       printf("RM_RX k%d Ind: %d (%d)\n",k-1,ind,w[ind]);

openair1/PHY/INIT/lte_init.c

@@ -883,10 +883,10 @@ int phy_init_lte_eNB(PHY_VARS_eNB *eNB,
     for (i=0; i<2; i++) {
       // RK 2 times because of output format of FFT!
       // FIXME We should get rid of this
-      pusch_vars[UE_id]->rxdataF_ext[i]      = (int32_t*)malloc16_clear( 2*sizeof(int32_t)*fp->N_RB_UL*12*fp->symbols_per_tti );
+      pusch_vars[UE_id]->rxdataF_ext[i]      = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->N_RB_UL*12*fp->symbols_per_tti );
       pusch_vars[UE_id]->rxdataF_ext2[i]     = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->N_RB_UL*12*fp->symbols_per_tti );
       pusch_vars[UE_id]->drs_ch_estimates[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->N_RB_UL*12*fp->symbols_per_tti );
-      pusch_vars[UE_id]->drs_ch_estimates_time[i] = (int32_t*)malloc16_clear( 2*2*sizeof(int32_t)*fp->ofdm_symbol_size );
+      pusch_vars[UE_id]->drs_ch_estimates_time[i] = (int32_t*)malloc16_clear( 2*sizeof(int32_t)*fp->ofdm_symbol_size );
       pusch_vars[UE_id]->rxdataF_comp[i]     = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->N_RB_UL*12*fp->symbols_per_tti );
       pusch_vars[UE_id]->ul_ch_mag[i]  = (int32_t*)malloc16_clear( fp->symbols_per_tti*sizeof(int32_t)*fp->N_RB_UL*12 );
       pusch_vars[UE_id]->ul_ch_magb[i] = (int32_t*)malloc16_clear( fp->symbols_per_tti*sizeof(int32_t)*fp->N_RB_UL*12 );

openair1/PHY/INIT/lte_init_ru.c

@@ -32,6 +32,11 @@
 #include "assertions.h"
 #include <math.h>
 
+#undef LOG_I
+#define LOG_I(A,B,C...) printf(B,C)
+#undef LOG_D
+#define LOG_D(A,B,C...) printf(B,C)
+
 int phy_init_RU(RU_t *ru) {
 
   LTE_DL_FRAME_PARMS *fp = &ru->frame_parms;
@@ -60,7 +65,7 @@ int phy_init_RU(RU_t *ru) {
     }
   } // IF5 or local RF
   else {
-    LOG_I(PHY,"No rxdata/txdata for RU\n");
+    //    LOG_I(PHY,"No rxdata/txdata for RU\n");
     ru->common.txdata        = (int32_t**)NULL;
     ru->common.rxdata        = (int32_t**)NULL;
 
@@ -91,8 +96,8 @@ int phy_init_RU(RU_t *ru) {
     }
 
     /* number of elements of an array X is computed as sizeof(X) / sizeof(X[0]) */
-    AssertFatal(ru->nb_rx <= sizeof(ru->prach_rxsigF) / sizeof(ru->prach_rxsigF[0]),
-		"nb_antennas_rx too large");
+    //    AssertFatal(ru->nb_rx <= sizeof(ru->prach_rxsigF) / sizeof(ru->prach_rxsigF[0]),
+    //		"nb_antennas_rx too large");
     ru->prach_rxsigF = (int16_t**)malloc(ru->nb_rx * sizeof(int16_t*));
     for (j=0;j<4;j++) ru->prach_rxsigF_br[j] = (int16_t**)malloc(ru->nb_rx * sizeof(int16_t*));
 

openair1/PHY/INIT/lte_param_init.c

@@ -109,10 +109,11 @@ void lte_param_init(PHY_VARS_eNB **eNBp,
 
   UE->is_secondary_ue = 0;
   UE->frame_parms = *frame_parms;
+  UE->frame_parms.nb_antennas_rx=1;
   //  eNB->frame_parms = *frame_parms;
   ru->frame_parms = *frame_parms;
   ru->nb_tx = N_tx_phy;
-  ru->nb_rx = 1;
+  ru->nb_rx = N_rx;
   ru->if_south = LOCAL_RF;
 
   eNB->configured=1;
@@ -155,6 +156,13 @@ void lte_param_init(PHY_VARS_eNB **eNBp,
   /* the UE code is multi-thread "aware", we need to setup this array */
   for (i = 0; i < 10; i++) UE->current_thread_id[i] = i % 2;
 
+  if (eNB->frame_parms.frame_type == TDD) {
+    if      (eNB->frame_parms.N_RB_DL == 100) ru->N_TA_offset = 624;
+    else if (eNB->frame_parms.N_RB_DL == 50)  ru->N_TA_offset = 624/2;
+    else if (eNB->frame_parms.N_RB_DL == 25)  ru->N_TA_offset = 624/4;
+  } 
+  else ru->N_TA_offset=0;
+
   printf("Done lte_param_init\n");
 
 

openair1/PHY/LTE_ESTIMATION/freq_equalization.c

@@ -306,7 +306,7 @@ void freq_equalization(LTE_DL_FRAME_PARMS *frame_parms,
 
   AssertFatal(symbol<frame_parms->symbols_per_tti,"symbol %d >= %d\n",
 	      symbol,frame_parms->symbols_per_tti);
-  AssertFatal(Msc_RS<frame_parms->N_RB_UL*12,"Msc_RS %d >= %d\n",
+  AssertFatal(Msc_RS<=frame_parms->N_RB_UL*12,"Msc_RS %d >= %d\n",
 	      Msc_RS,frame_parms->N_RB_UL*12);
 
   for (re=0; re<(Msc_RS>>2); re++) {

openair1/PHY/LTE_ESTIMATION/lte_ul_channel_estimation.c

@@ -34,6 +34,9 @@ static int16_t ru_90c[2*128] = {32767, 0,32766, -402,32758, -804,32746, -1206,32
 
 #define SCALE 0x3FFF
 
+//#undef LOG_D
+//#define LOG_D(A,B,C...) printf(B,C)
+
 int32_t lte_ul_channel_estimation(PHY_VARS_eNB *eNB,
 				  eNB_rxtx_proc_t *proc,
                                   uint8_t UE_id,
@@ -100,7 +103,7 @@ int32_t temp_in_ifft_0[2048*2] __attribute__((aligned(32)));
     return(-1);
   }
 
-  //  LOG_I(PHY,"subframe %d, Ns %d, l %d, Msc_RS = %d, Msc_RS_idx = %d, u %d, v %d, cyclic_shift %d\n",subframe,Ns,l,Msc_RS, Msc_RS_idx,u,v,cyclic_shift);
+  LOG_D(PHY,"subframe %d, Ns %d, l %d, Msc_RS = %d, Msc_RS_idx = %d, u %d, v %d, cyclic_shift %d\n",subframe,Ns,l,Msc_RS, Msc_RS_idx,u,v,cyclic_shift);
 #ifdef DEBUG_CH
 
   if (Ns==0)

openair1/PHY/LTE_TRANSPORT/dci_tools.c

@@ -44,10 +44,11 @@
 #include "LAYER2/MAC/extern.h"
 #include "LAYER2/MAC/defs.h"
 
-//#undef LOG_D
-//#define LOG_D(A,B,C...) printf(B,C)
-//#undef LOG_I
-//#define LOG_I(A,B,C...) printf(B,C)
+/*#undef LOG_D
+#define LOG_D(A,B,C...) printf(B,C)
+#undef LOG_I
+#define LOG_I(A,B,C...) printf(B,C)
+*/
 
 //#define DEBUG_DCI
 
@@ -2665,11 +2666,12 @@ void fill_ulsch(PHY_VARS_eNB *eNB,nfapi_ul_config_ulsch_pdu *ulsch_pdu,int frame
   else if(ulsch->harq_processes[harq_pid]->n_DMRS == 7)
     ulsch->harq_processes[harq_pid]->n_DMRS2 = 9;
   
-  LOG_D(PHY,"[eNB %d][PUSCH %d] Frame %d, Subframe %d Programming PUSCH with n_DMRS2 %d (cshift %d) ulsch:ndi:%d ulsch_pdu:ndi:%d new_ulsch:%d status:%d\n",
+  LOG_D(PHY,"[eNB %d][PUSCH %d] Frame %d, Subframe %d Programming PUSCH with n_DMRS2 %d (cshift %d) ulsch:ndi:%d ulsch_pdu:ndi:%d new_ulsch:%d status:%d ulsch_pdu:rvidx:%d\n",
 	eNB->Mod_id,harq_pid,frame,subframe,
         ulsch->harq_processes[harq_pid]->n_DMRS2,
         ulsch->harq_processes[harq_pid]->n_DMRS,
-	ulsch->harq_processes[harq_pid]->ndi, ulsch_pdu->ulsch_pdu_rel8.new_data_indication, new_ulsch, ulsch->harq_processes[harq_pid]->status);
+	ulsch->harq_processes[harq_pid]->ndi, ulsch_pdu->ulsch_pdu_rel8.new_data_indication, new_ulsch, ulsch->harq_processes[harq_pid]->status,
+	ulsch_pdu->ulsch_pdu_rel8.redundancy_version);
   
   ulsch->harq_processes[harq_pid]->rvidx = ulsch_pdu->ulsch_pdu_rel8.redundancy_version;
   ulsch->harq_processes[harq_pid]->Qm    = ulsch_pdu->ulsch_pdu_rel8.modulation_type;

openair1/PHY/LTE_TRANSPORT/drs_modulation.c

@@ -94,8 +94,10 @@ int generate_drs_pusch(PHY_VARS_UE *ue,
        l<frame_parms->symbols_per_tti;
        l += (7 - frame_parms->Ncp),u=u1,v=v1,cyclic_shift=cyclic_shift1) {
 
-    drs_offset = 0;  //  printf("drs_modulation: Msc_RS = %d, Msc_RS_idx = %d\n",Msc_RS, Msc_RS_idx);
-
+    drs_offset = 0;  
+#ifdef DEBUG_DRS
+    printf("drs_modulation: Msc_RS = %d, Msc_RS_idx = %d, u=%d,v=%d\n",Msc_RS, Msc_RS_idx,u,v);
+#endif
 
 
     re_offset = frame_parms->first_carrier_offset;

openair1/PHY/LTE_TRANSPORT/proto.h

@@ -1783,7 +1783,7 @@ int generate_eNB_ulsch_params_from_dci(PHY_VARS_eNB *PHY_vars_eNB,
                                        uint8_t use_srs);
 
 
-void dump_ulsch(PHY_VARS_eNB *phy_vars_eNB,int frame, int subframe, uint8_t UE_id);
+void dump_ulsch(PHY_VARS_eNB *phy_vars_eNB,int frame, int subframe, uint8_t UE_id,int round);
 
 int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci);
 

openair1/PHY/LTE_TRANSPORT/ulsch_demodulation.c

@@ -725,8 +725,8 @@ void ulsch_extract_rbs_single(int32_t **rxdataF,
   //uint8_t symbol = l+Ns*frame_parms->symbols_per_tti/2;
   uint8_t symbol = l+((7-frame_parms->Ncp)*(Ns&1)); ///symbol within sub-frame
 
-  AssertFatal((frame_parms->nb_antennas_rx>0) && (frame_parms->nb_antennas_rx<3),
-	      "nb_antennas_rx not in (1-2)\n");
+  AssertFatal((frame_parms->nb_antennas_rx>0) && (frame_parms->nb_antennas_rx<5),
+	      "nb_antennas_rx not in (1-4)\n");
 
   for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
 
@@ -1349,35 +1349,54 @@ void rx_ulsch_emul(PHY_VARS_eNB *eNB,
 }
 
 
- void dump_ulsch(PHY_VARS_eNB *eNB,int frame,int subframe,uint8_t UE_id) {
+ void dump_ulsch(PHY_VARS_eNB *eNB,int frame,int subframe,uint8_t UE_id,int round) {
   
   uint32_t nsymb = (eNB->frame_parms.Ncp == 0) ? 14 : 12;
   uint8_t harq_pid;
+  char fname[100],vname[100];
 
   harq_pid = subframe2harq_pid(&eNB->frame_parms,frame,subframe);
 
-  printf("Dumping ULSCH in subframe %d with harq_pid %d, for NB_rb %d, TBS %d, Qm %d, N_symb %d\n", 
-	 subframe,harq_pid,eNB->ulsch[UE_id]->harq_processes[harq_pid]->nb_rb,
+  printf("Dumping ULSCH in subframe %d with harq_pid %d, round %d for NB_rb %d, TBS %d, Qm %d, N_symb %d\n", 
+	 subframe,harq_pid,round,eNB->ulsch[UE_id]->harq_processes[harq_pid]->nb_rb,
          eNB->ulsch[UE_id]->harq_processes[harq_pid]->TBS,eNB->ulsch[UE_id]->harq_processes[harq_pid]->Qm,
          eNB->ulsch[UE_id]->harq_processes[harq_pid]->Nsymb_pusch);
-  write_output("/tmp/ulsch_d.m","ulsch_dseq",&eNB->ulsch[UE_id]->harq_processes[harq_pid]->d[0][96],
+  sprintf(fname,"/tmp/ulsch_r%d_d",round);
+  sprintf(vname,"/tmp/ulsch_r%d_dseq",round);
+  write_output(fname,vname,&eNB->ulsch[UE_id]->harq_processes[harq_pid]->d[0][96],
                eNB->ulsch[UE_id]->harq_processes[harq_pid]->Kplus*3,1,0);
-  if (eNB->common_vars.rxdata) write_output("/tmp/rxsig0.m","rxs0", &eNB->common_vars.rxdata[0][0],eNB->frame_parms.samples_per_tti*10,1,1);
+  if (eNB->common_vars.rxdata) {
+    sprintf(fname,"/tmp/rxsig0_r%d.m",round);
+    sprintf(vname,"rxs0_r%d",round);
+    write_output(fname,vname, &eNB->common_vars.rxdata[0][0],eNB->frame_parms.samples_per_tti*10,1,1);
   
     if (eNB->frame_parms.nb_antennas_rx>1)
-    if (eNB->common_vars.rxdata) write_output("/tmp/rxsig1.m","rxs1", &eNB->common_vars.rxdata[1][0],eNB->frame_parms.samples_per_tti*10,1,1);
-  
-
-  write_output("/tmp/rxsigF0.m","rxsF0", &eNB->common_vars.rxdataF[0][0],eNB->frame_parms.ofdm_symbol_size*nsymb,1,1);
+      if (eNB->common_vars.rxdata) {
+	sprintf(fname,"/tmp/rxsig1_r%d.m",round);
+	sprintf(vname,"rxs1_r%d",round);
+	write_output(fname,vname, &eNB->common_vars.rxdata[1][0],eNB->frame_parms.samples_per_tti*10,1,1);
+      }
+  }
 
-  if (eNB->frame_parms.nb_antennas_rx>1)
-    write_output("/tmp/rxsigF1.m","rxsF1", &eNB->common_vars.rxdataF[1][0],eNB->frame_parms.ofdm_symbol_size*nsymb,1,1);
+  sprintf(fname,"/tmp/rxsigF0_r%d.m",round);
+  sprintf(vname,"rxsF0_r%d",round);
+  write_output(fname,vname, (void*)&eNB->common_vars.rxdataF[0][0],eNB->frame_parms.ofdm_symbol_size*nsymb,1,1);
 
-  write_output("/tmp/rxsigF0_ext.m","rxsF0_ext", &eNB->pusch_vars[UE_id]->rxdataF_ext[0][0],eNB->frame_parms.N_RB_UL*12*nsymb,1,1);
+  if (eNB->frame_parms.nb_antennas_rx>1) {
+    sprintf(fname,"/tmp/rxsigF1_r%d.m",round);
+    sprintf(vname,"rxsF1_r%d",round);
+    write_output(vname,fname, &eNB->common_vars.rxdataF[1][0],eNB->frame_parms.ofdm_symbol_size*nsymb,1,1);
+  }
 
-  if (eNB->frame_parms.nb_antennas_rx>1)
-    write_output("/tmp/rxsigF1_ext.m","rxsF1_ext", &eNB->pusch_vars[UE_id]->rxdataF_ext[0][0],eNB->frame_parms.N_RB_UL*12*nsymb,1,1);
+  sprintf(fname,"/tmp/rxsigF0_ext_r%d.m",round);
+  sprintf(vname,"rxsF0_ext_r%d",round);
+  write_output(fname,vname, &eNB->pusch_vars[UE_id]->rxdataF_ext[0][0],eNB->frame_parms.N_RB_UL*12*nsymb,1,1);
 
+  if (eNB->frame_parms.nb_antennas_rx>1) {
+    sprintf(fname,"/tmp/rxsigF1_ext_r%d.m",round);
+    sprintf(vname,"rxsF1_ext_r%d",round);
+    write_output(fname,vname,&eNB->pusch_vars[UE_id]->rxdataF_ext[0][0],eNB->frame_parms.N_RB_UL*12*nsymb,1,1);
+  }
   /*
   if (eNB->srs_vars[UE_id].srs_ch_estimates) write_output("/tmp/srs_est0.m","srsest0",eNB->srs_vars[UE_id].srs_ch_estimates[0],eNB->frame_parms.ofdm_symbol_size,1,1);
 
@@ -1385,17 +1404,28 @@ void rx_ulsch_emul(PHY_VARS_eNB *eNB,
     if (eNB->srs_vars[UE_id].srs_ch_estimates) write_output("/tmp/srs_est1.m","srsest1",eNB->srs_vars[UE_id].srs_ch_estimates[1],eNB->frame_parms.ofdm_symbol_size,1,1);
   */
 
-  write_output("/tmp/drs_est0.m","drsest0",eNB->pusch_vars[UE_id]->drs_ch_estimates[0],eNB->frame_parms.N_RB_UL*12*nsymb,1,1);
+  sprintf(fname,"/tmp/drs_est0_r%d.m",round);
+  sprintf(vname,"drsest0_r%d",round);
+  write_output(fname,vname,eNB->pusch_vars[UE_id]->drs_ch_estimates[0],eNB->frame_parms.N_RB_UL*12*nsymb,1,1);
 
-  if (eNB->frame_parms.nb_antennas_rx>1)
-    write_output("/tmp/drs_est1.m","drsest1",eNB->pusch_vars[UE_id]->drs_ch_estimates[1],eNB->frame_parms.N_RB_UL*12*nsymb,1,1);
+  if (eNB->frame_parms.nb_antennas_rx>1) {
+    sprintf(fname,"/tmp/drs_est1_r%d.m",round);
+    sprintf(vname,"drsest1_r%d",round);
+    write_output(fname,vname,eNB->pusch_vars[UE_id]->drs_ch_estimates[1],eNB->frame_parms.N_RB_UL*12*nsymb,1,1);
+  }
 
-  write_output("/tmp/ulsch_rxF_comp0.m","ulsch0_rxF_comp0",&eNB->pusch_vars[UE_id]->rxdataF_comp[0][0],eNB->frame_parms.N_RB_UL*12*nsymb,1,1);
+  sprintf(fname,"/tmp/ulsch0_rxF_comp0_r%d.m",round);
+  sprintf(vname,"ulsch0_rxF_comp0_r%d",round);
+  write_output(fname,vname,&eNB->pusch_vars[UE_id]->rxdataF_comp[0][0],eNB->frame_parms.N_RB_UL*12*nsymb,1,1);
   //  write_output("ulsch_rxF_comp1.m","ulsch0_rxF_comp1",&eNB->pusch_vars[UE_id]->rxdataF_comp[0][1][0],eNB->frame_parms.N_RB_UL*12*nsymb,1,1);
-  write_output("/tmp/ulsch_rxF_llr.m","ulsch_llr",eNB->pusch_vars[UE_id]->llr,
+  sprintf(fname,"/tmp/ulsch_rxF_llr_r%d.m",round);
+  sprintf(vname,"ulsch_llr_r%d",round);
+  write_output(fname,vname,eNB->pusch_vars[UE_id]->llr,
                eNB->ulsch[UE_id]->harq_processes[harq_pid]->nb_rb*12*eNB->ulsch[UE_id]->harq_processes[harq_pid]->Qm
                *eNB->ulsch[UE_id]->harq_processes[harq_pid]->Nsymb_pusch,1,0);
-  write_output("/tmp/ulsch_ch_mag.m","ulsch_ch_mag",&eNB->pusch_vars[UE_id]->ul_ch_mag[0][0],eNB->frame_parms.N_RB_UL*12*nsymb,1,1);
+  sprintf(fname,"/tmp/ulsch_ch_mag_r%d.m",round);
+  sprintf(vname,"ulsch_ch_mag_r%d",round);
+  write_output(fname,vname,&eNB->pusch_vars[UE_id]->ul_ch_mag[0][0],eNB->frame_parms.N_RB_UL*12*nsymb,1,1);
   //  write_output("ulsch_ch_mag1.m","ulsch_ch_mag1",&eNB->pusch_vars[UE_id]->ul_ch_mag[1][0],eNB->frame_parms.N_RB_UL*12*nsymb,1,1);
   //#endif
 }

openair1/PHY/MODULATION/slot_fep_ul.c

@@ -24,6 +24,9 @@
 #include "defs.h"
 //#define DEBUG_FEP
 
+//#undef LOG_D
+//#define LOG_D(A,B,C...) printf(B,C)
+
 int slot_fep_ul(RU_t *ru,
                 unsigned char l,
                 unsigned char Ns,
@@ -134,7 +137,7 @@ int slot_fep_ul(RU_t *ru,
   }
 
 #ifdef DEBUG_FEP
-  LOG_D(PHY,"slot_fep: done\n");
+  //  LOG_D(PHY,"slot_fep: done\n");
 #endif
   return(0);
 }

openair1/PHY/MODULATION/ul_7_5_kHz.c

@@ -188,7 +188,7 @@ void remove_7_5_kHz(RU_t *ru,uint8_t slot)
   }
 
 
-  slot_offset = (uint32_t)slot * frame_parms->samples_per_tti/2-ru->N_TA_offset;
+  slot_offset = ((uint32_t)slot * frame_parms->samples_per_tti/2)-ru->N_TA_offset;
   slot_offset2 = (uint32_t)(slot&1) * frame_parms->samples_per_tti/2;
 
   len = frame_parms->samples_per_tti/2;

openair1/SCHED/fapi_l1.c

@@ -37,10 +37,11 @@
 #include "nfapi_interface.h"
 #include "fapi_l1.h"
 
-//#undef LOG_D
-//#define LOG_D(A,B,C...) printf(B,C)
-//#undef LOG_I
-//#define LOG_I(A,B,C...) printf(B,C)
+/*#undef LOG_D
+#define LOG_D(A,B,C...) printf(B,C)
+#undef LOG_I
+#define LOG_I(A,B,C...) printf(B,C)
+*/
 
 int oai_nfapi_dl_config_req(nfapi_dl_config_request_t *dl_config_req);
 int oai_nfapi_tx_req(nfapi_tx_request_t *tx_req);
@@ -542,7 +543,7 @@ void handle_nfapi_ul_pdu(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,
   if (ul_config_pdu->pdu_type == NFAPI_UL_CONFIG_ULSCH_PDU_TYPE) {
     AssertFatal((UE_id = find_ulsch(ul_config_pdu->ulsch_pdu.ulsch_pdu_rel8.rnti,eNB,SEARCH_EXIST_OR_FREE))>=0,
                 "No existing UE ULSCH for rnti %x\n",rel8->rnti);
-    //LOG_D(PHY,"Applying UL config for UE %d, rnti %x for frame %d, subframe %d\n", UE_id,rel8->rnti,frame,subframe);
+    LOG_D(PHY,"Applying UL config for UE %d, rnti %x for frame %d, subframe %d, modulation %d, rvidx %d\n", UE_id,rel8->rnti,frame,subframe,rel8->modulation_type,rel8->redundancy_version);
 
     fill_ulsch(eNB,&ul_config_pdu->ulsch_pdu,frame,subframe);
 

openair1/SCHED/phy_procedures_lte_eNb.c

@@ -50,8 +50,10 @@
 #   include "intertask_interface.h"
 #endif
 
-//#undef LOG_D
-//#define LOG_D(A,B,C...) printf(B,C)
+/*
+#undef LOG_D
+#define LOG_D(A,B,C...) printf(B,C)
+*/
 
 extern uint8_t nfapi_mode;
 int oai_nfapi_rach_ind(nfapi_rach_indication_t *rach_ind);
@@ -1263,12 +1265,12 @@ void pusch_procedures(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc)
 	LOG_D(PHY,"[eNB %d][PUSCH %d] frame %d subframe %d UE %d Error receiving ULSCH, round %d/%d (ACK %d,%d)\n",
 	      eNB->Mod_id,harq_pid,
 	      frame,subframe, i,
-	      ulsch_harq->round-1,
+	      ulsch_harq->round,
 	      ulsch->Mlimit,
 	      ulsch_harq->o_ACK[0],
 	      ulsch_harq->o_ACK[1]);
 
-        if (ulsch_harq->round >= 3)  {
+        if (ulsch_harq->round >= 4)  {
            ulsch_harq->status  = SCH_IDLE;
            ulsch_harq->handled = 0;
            ulsch->harq_mask   &= ~(1 << harq_pid);

openair1/SCHED/phy_procedures_lte_ue.c

@@ -76,6 +76,7 @@ extern double cpuf;
 //#undef LOG_D
 //#define LOG_D(A,B,C...) printf(B,C)
 
+
 void Msg1_transmitted(module_id_t module_idP,uint8_t CC_id,frame_t frameP, uint8_t eNB_id);
 void Msg3_transmitted(module_id_t module_idP,uint8_t CC_id,frame_t frameP, uint8_t eNB_id);
 
@@ -84,7 +85,7 @@ extern uint32_t downlink_frequency[MAX_NUM_CCs][4];
 #endif
 
 
-#define DEBUG_UE_TRACE 1
+#define UE_DEBUG_TRACE 1
 
 void dump_dlsch(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uint8_t subframe,uint8_t harq_pid)
 {
@@ -1269,7 +1270,7 @@ void ulsch_common_procedures(PHY_VARS_UE *ue, UE_rxtx_proc_t *proc, uint8_t empt
   }
 //#endif
 
-  if ((frame_tx%100) == 0)
+//  if ((frame_tx%100) == 0)
     LOG_D(PHY,"[UE %d] Frame %d, subframe %d: ulsch_start = %d (rxoff %d, HW TA %d, timing advance %d, TA_offset %d\n",
     ue->Mod_id,frame_tx,subframe_tx,
     ulsch_start,
@@ -1291,16 +1292,25 @@ void ulsch_common_procedures(PHY_VARS_UE *ue, UE_rxtx_proc_t *proc, uint8_t empt
        nsymb,
        frame_parms->nb_prefix_samples,
        CYCLIC_PREFIX);
-    else
+    else {
       normal_prefix_mod(&ue->common_vars.txdataF[aa][subframe_tx*nsymb*frame_parms->ofdm_symbol_size],
 #if defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_BLADERF) || defined(OAI_LMSSDR)
 			dummy_tx_buffer,
 #else
 			&ue->common_vars.txdata[aa][ulsch_start],
 #endif
-      nsymb,
+			nsymb>>1,
 			&ue->frame_parms);
       
+      normal_prefix_mod(&ue->common_vars.txdataF[aa][((subframe_tx*nsymb)+(nsymb>>1))*frame_parms->ofdm_symbol_size],
+#if defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_BLADERF) || defined(OAI_LMSSDR)
+			dummy_tx_buffer+(frame_parms->samples_per_tti>>1),
+#else
+			&ue->common_vars.txdata[aa][ulsch_start+(frame_parms->samples_per_tti>>1)],
+#endif
+			nsymb>>1,
+			&ue->frame_parms);
+      }
 
 #if defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_BLADERF) || defined(OAI_LMSSDR)
     apply_7_5_kHz(ue,dummy_tx_buffer,0);

openair1/SCHED/ru_procedures.c

@@ -539,6 +539,7 @@ void fep_full(RU_t *ru) {
   
   remove_7_5_kHz(ru,proc->subframe_rx<<1);
   remove_7_5_kHz(ru,1+(proc->subframe_rx<<1));
+
   for (l=0; l<fp->symbols_per_tti/2; l++) {
     slot_fep_ul(ru,
 		l,

openair1/SIMULATION/LTE_PHY/dlsim.c

@@ -1409,8 +1409,8 @@ int main(int argc, char **argv)
   if (input_fd==NULL) {
 
     DL_req.dl_config_request_body.number_pdcch_ofdm_symbols = num_pdcch_symbols;
-    DL_req.sfn_sf = (proc_eNB->frame_tx*10)+subframe;
-    TX_req.sfn_sf = (proc_eNB->frame_tx*10)+subframe;
+    DL_req.sfn_sf = (proc_eNB->frame_tx<<4)+subframe;
+    TX_req.sfn_sf = (proc_eNB->frame_tx<<4)+subframe;
     // UE specific DCI
     fill_DCI(eNB,
 	     proc_eNB->frame_tx,subframe,