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,

openair1/SIMULATION/LTE_PHY/ulsim.c

@@ -47,9 +47,7 @@
 #include "unitary_defs.h"
 
 #include "PHY/TOOLS/lte_phy_scope.h"
-
-PHY_VARS_eNB *eNB;
-PHY_VARS_UE *UE;
+#include "dummy_functions.c"
 
 double cpuf;
 
@@ -78,9 +76,112 @@ double t_tx_min = 1000000000; /*!< \brief initial min process time for tx */
 double t_rx_min = 1000000000; /*!< \brief initial min process time for tx */
 int n_tx_dropped = 0; /*!< \brief initial max process time for tx */
 int n_rx_dropped = 0; /*!< \brief initial max process time for rx */
+int nfapi_mode = 0;
+
+extern void fep_full(RU_t *ru);
+extern void ru_fep_full_2thread(RU_t *ru);
+
+nfapi_dl_config_request_t DL_req;
+nfapi_ul_config_request_t UL_req;
+nfapi_hi_dci0_request_t HI_DCI0_req;
+nfapi_ul_config_request_pdu_t ul_config_pdu_list[MAX_NUM_DL_PDU]; 
+nfapi_tx_request_pdu_t tx_pdu_list[MAX_NUM_TX_REQUEST_PDU];
+nfapi_tx_request_t TX_req;
+Sched_Rsp_t sched_resp;
+
+void
+fill_nfapi_ulsch_config_request(nfapi_ul_config_request_pdu_t *ul_config_pdu, 
+				uint8_t                        cqi_req,
+				uint8_t                        p_eNB,
+				uint8_t                        cqi_ReportModeAperiodic,
+				uint8_t                        betaOffset_CQI_Index,
+				uint8_t                        betaOffset_RI_Index,
+				uint8_t                        dl_cqi_pmi_size,
+				uint8_t                        tmode, 
+				uint32_t                       handle,
+				uint16_t                       rnti,
+				uint8_t                        resource_block_start,
+				uint8_t                        number_of_resource_blocks,
+				uint8_t                        modulation_type,
+				uint8_t                        cyclic_shift_2_for_drms,
+				uint8_t                        frequency_hopping_enabled_flag,
+				uint8_t                        frequency_hopping_bits,
+				uint8_t                        new_data_indication,
+				uint8_t                        redundancy_version,
+				uint8_t                        harq_process_number,
+				uint8_t                        ul_tx_mode,
+				uint8_t                        current_tx_nb,
+				uint8_t                        n_srs, 
+				uint16_t                       size)
+{
+  memset((void *) ul_config_pdu, 0, sizeof(nfapi_ul_config_request_pdu_t));
+
+  //  printf("filling ul_config_pdu: modulation type %d, rvidx %d\n",modulation_type,redundancy_version);
+
+  ul_config_pdu->pdu_type                                                    = NFAPI_UL_CONFIG_ULSCH_PDU_TYPE;
+  ul_config_pdu->pdu_size                                                    = (uint8_t) (2 + sizeof(nfapi_ul_config_ulsch_pdu));
+  ul_config_pdu->ulsch_pdu.ulsch_pdu_rel8.tl.tag                             = NFAPI_UL_CONFIG_REQUEST_ULSCH_PDU_REL8_TAG;
+  ul_config_pdu->ulsch_pdu.ulsch_pdu_rel8.handle                             = handle;
+  ul_config_pdu->ulsch_pdu.ulsch_pdu_rel8.rnti                               = rnti;
+  ul_config_pdu->ulsch_pdu.ulsch_pdu_rel8.resource_block_start               = resource_block_start;
+  ul_config_pdu->ulsch_pdu.ulsch_pdu_rel8.number_of_resource_blocks          = number_of_resource_blocks;
+  ul_config_pdu->ulsch_pdu.ulsch_pdu_rel8.modulation_type                    = modulation_type;
+  ul_config_pdu->ulsch_pdu.ulsch_pdu_rel8.cyclic_shift_2_for_drms            = cyclic_shift_2_for_drms;
+  ul_config_pdu->ulsch_pdu.ulsch_pdu_rel8.frequency_hopping_enabled_flag     = frequency_hopping_enabled_flag;
+  ul_config_pdu->ulsch_pdu.ulsch_pdu_rel8.frequency_hopping_bits             = frequency_hopping_bits;
+  ul_config_pdu->ulsch_pdu.ulsch_pdu_rel8.new_data_indication                = new_data_indication;
+  ul_config_pdu->ulsch_pdu.ulsch_pdu_rel8.redundancy_version                 = redundancy_version;
+  ul_config_pdu->ulsch_pdu.ulsch_pdu_rel8.harq_process_number                = harq_process_number;
+  ul_config_pdu->ulsch_pdu.ulsch_pdu_rel8.ul_tx_mode                         = ul_tx_mode;
+  ul_config_pdu->ulsch_pdu.ulsch_pdu_rel8.current_tx_nb                      = current_tx_nb;
+  ul_config_pdu->ulsch_pdu.ulsch_pdu_rel8.n_srs                              = n_srs;
+  ul_config_pdu->ulsch_pdu.ulsch_pdu_rel8.size                               = size;
+
+  if (cqi_req == 1) {
+    // Add CQI portion
+    ul_config_pdu->pdu_type = NFAPI_UL_CONFIG_ULSCH_CQI_RI_PDU_TYPE;
+    ul_config_pdu->pdu_size = (uint8_t) (2 + sizeof(nfapi_ul_config_ulsch_cqi_ri_pdu));
+    ul_config_pdu->ulsch_cqi_ri_pdu.cqi_ri_information.cqi_ri_information_rel9.tl.tag = NFAPI_UL_CONFIG_REQUEST_CQI_RI_INFORMATION_REL9_TAG;
+    ul_config_pdu->ulsch_cqi_ri_pdu.cqi_ri_information.cqi_ri_information_rel9.report_type = 1;
+    ul_config_pdu->ulsch_cqi_ri_pdu.cqi_ri_information.cqi_ri_information_rel9.aperiodic_cqi_pmi_ri_report.number_of_cc = 1;
+    LOG_D(MAC, "report_type %d\n",ul_config_pdu->ulsch_cqi_ri_pdu.cqi_ri_information.cqi_ri_information_rel9.report_type);
+
+    if (p_eNB <= 2
+	&& (tmode == 3 || tmode == 4 || tmode == 8 || tmode == 9 || tmode == 10))
+      ul_config_pdu->ulsch_cqi_ri_pdu.cqi_ri_information.cqi_ri_information_rel9.aperiodic_cqi_pmi_ri_report.cc[0].ri_size = 1;
+    else if (p_eNB <= 2) ul_config_pdu->ulsch_cqi_ri_pdu.cqi_ri_information.cqi_ri_information_rel9.aperiodic_cqi_pmi_ri_report.cc[0].ri_size = 0;
+    else if (p_eNB == 4) ul_config_pdu->ulsch_cqi_ri_pdu.cqi_ri_information.cqi_ri_information_rel9.aperiodic_cqi_pmi_ri_report.cc[0].ri_size = 2;
+
+    for (int ri = 0; 
+	 ri <  (1 << ul_config_pdu->ulsch_cqi_ri_pdu.cqi_ri_information.cqi_ri_information_rel9.aperiodic_cqi_pmi_ri_report.cc[0].ri_size); 
+	 ri++)
+      ul_config_pdu->ulsch_cqi_ri_pdu.cqi_ri_information.cqi_ri_information_rel9.aperiodic_cqi_pmi_ri_report.cc[0].dl_cqi_pmi_size[ri] =	dl_cqi_pmi_size;
+    
+    ul_config_pdu->ulsch_cqi_ri_pdu.cqi_ri_information.cqi_ri_information_rel9.delta_offset_cqi = betaOffset_CQI_Index;
+    ul_config_pdu->ulsch_cqi_ri_pdu.cqi_ri_information.cqi_ri_information_rel9.delta_offset_ri  = betaOffset_RI_Index;
+  }
+}
 
-
-void fill_ulsch_dci(PHY_VARS_eNB *eNB,void *UL_dci,int first_rb,int nb_rb,int mcs,int ndi,int cqi_flag) {
+void fill_ulsch_dci(PHY_VARS_eNB *eNB,
+		    int frame,
+		    int subframe,
+		    Sched_Rsp_t *sched_resp,
+		    uint16_t rnti,
+		    void *UL_dci,
+		    int first_rb,
+		    int nb_rb,
+		    int mcs,
+		    int modulation_type,
+		    int ndi,
+		    int cqi_flag,
+		    uint8_t beta_CQI,
+		    uint8_t beta_RI,
+		    uint8_t cqi_size) {
+
+  nfapi_ul_config_request_body_t *ul_req=&sched_resp->UL_req->ul_config_request_body;
+  int harq_pid = ((frame*10)+subframe)&7;
+
+  //  printf("ulsch in frame %d, subframe %d => harq_pid %d, mcs %d, ndi %d\n",frame,subframe,harq_pid,mcs,ndi);
 
   switch (eNB->frame_parms.N_RB_UL) {
   case 6:
@@ -162,6 +263,36 @@ void fill_ulsch_dci(PHY_VARS_eNB *eNB,void *UL_dci,int first_rb,int nb_rb,int mc
     break;
   }
 
+  fill_nfapi_ulsch_config_request(&ul_req->ul_config_pdu_list[0], 
+				  cqi_flag&1, 
+				  1,  // p_eNB
+				  0,  // reportmode Aperiodic
+				  beta_CQI,
+				  beta_RI,
+				  cqi_size,
+				  //cc, 
+				  //UE_template->physicalConfigDedicated, 
+				  1,
+				  0, 
+				  14,     // rnti
+				  first_rb,	// resource_block_start
+				  nb_rb,	// number_of_resource_blocks
+				  modulation_type,
+				  0,	// cyclic_shift_2_for_drms
+				  0,	// frequency_hopping_enabled_flag
+				  0,	// frequency_hopping_bits
+				  ndi,	// new_data_indication
+				  mcs>28?(mcs-28):0,	// redundancy_version
+				  harq_pid,	// harq_process_number
+				  0,	// ul_tx_mode
+				  0,	// current_tx_nb
+				  0,	// n_srs
+				  get_TBS_UL(mcs,nb_rb));
+
+  sched_resp->UL_req->header.message_id = NFAPI_UL_CONFIG_REQUEST;
+  ul_req->number_of_pdus=1;
+  ul_req->tl.tag = NFAPI_UL_CONFIG_REQUEST_BODY_TAG;
+  
 }
 
 extern void eNB_fep_full(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc);
@@ -172,22 +303,26 @@ int main(int argc, char **argv)
 
   char c;
   int i,j,aa,u;
-
+  PHY_VARS_eNB *eNB;
+  PHY_VARS_UE *UE;
+  RU_t *ru;
   int aarx,aatx;
   double channelx,channely;
   double sigma2, sigma2_dB=10,SNR,SNR2=0,snr0=-2.0,snr1,SNRmeas,rate,saving_bler=0;
   double input_snr_step=.2,snr_int=30;
   double blerr;
-
+  int rvidx[8]={0,2,3,1,0,2,3,1};
   int **txdata;
 
   LTE_DL_FRAME_PARMS *frame_parms;
   double s_re0[30720],s_im0[30720],r_re0[30720],r_im0[30720];
   double s_re1[30720],s_im1[30720],r_re1[30720],r_im1[30720];
+  double r_re2[30720],r_im2[30720];
+  double r_re3[30720],r_im3[30720];
   double *s_re[2]={s_re0,s_re1};
   double *s_im[2]={s_im0,s_im1};
-  double *r_re[2]={r_re0,r_re1};
-  double *r_im[2]={r_im0,r_im1};
+  double *r_re[4]={r_re0,r_re1,r_re2,r_re3};
+  double *r_im[4]={r_im0,r_im1,r_im2,r_im3};
   double forgetting_factor=0.0; //in [0,1] 0 means a new channel every time, 1 means keep the same channel
   double iqim=0.0;
   uint8_t extended_prefix_flag=0;
@@ -254,8 +389,7 @@ int main(int argc, char **argv)
   uint8_t N_RB_DL=25,osf=1;
 
   //uint8_t cyclic_shift = 0;
-  uint8_t cooperation_flag = 0; //0 no cooperation, 1 delay diversity, 2 Alamouti
-  uint8_t beta_ACK=0,beta_RI=0,beta_CQI=2;
+  uint8_t beta_ACK=0,beta_RI=0,beta_CQI=2,cqi_size=11;
   uint8_t tdd_config=3,frame_type=FDD;
 
   uint8_t N0=30;
@@ -282,10 +416,24 @@ int main(int argc, char **argv)
 
   opp_enabled=1; // to enable the time meas
 
+  sched_resp.DL_req = &DL_req;
+  sched_resp.UL_req = &UL_req;
+  sched_resp.HI_DCI0_req = &HI_DCI0_req;
+  sched_resp.TX_req = &TX_req;
+  memset((void*)&DL_req,0,sizeof(DL_req));
+  memset((void*)&UL_req,0,sizeof(UL_req));
+  memset((void*)&HI_DCI0_req,0,sizeof(HI_DCI0_req));
+  memset((void*)&TX_req,0,sizeof(TX_req));
+
+  UL_req.ul_config_request_body.ul_config_pdu_list = ul_config_pdu_list;
+  TX_req.tx_request_body.tx_pdu_list = tx_pdu_list;
+
   cpu_freq_GHz = (double)get_cpu_freq_GHz();
   cpuf = cpu_freq_GHz;
 
   printf("Detected cpu_freq %f GHz\n",cpu_freq_GHz);
+  AssertFatal(load_configmodule(argc,argv) != NULL,
+	      "cannot load configuration module, exiting\n");
 
   logInit();
   /*
@@ -565,8 +713,11 @@ int main(int argc, char **argv)
       break;
     }
   }
+  RC.nb_L1_inst = 1;
+  RC.nb_RU = 1;
 
-  lte_param_init(1,
+  lte_param_init(&eNB,&UE,&ru,
+		 1,
 		 1,
 		 n_rx,
 		 1,
@@ -575,10 +726,30 @@ int main(int argc, char **argv)
 		 0,
 		 tdd_config,
 		 N_RB_DL,
+		 4,
 		 threequarter_fs,
 		 osf,
 		 0);
 
+  RC.eNB = (PHY_VARS_eNB ***)malloc(sizeof(PHY_VARS_eNB **));
+  RC.eNB[0] = (PHY_VARS_eNB **)malloc(sizeof(PHY_VARS_eNB *));
+  RC.ru = (RU_t **)malloc(sizeof(RC.ru));
+  RC.eNB[0][0] = eNB;
+  RC.ru[0] = ru;
+  for (int k=0;k<eNB->RU_list[0]->nb_rx;k++) eNB->common_vars.rxdataF[k]     =  eNB->RU_list[0]->common.rxdataF[k];
+
+  memset((void*)&eNB->UL_INFO,0,sizeof(eNB->UL_INFO));
+  
+  printf("Setting indication lists\n");
+  eNB->UL_INFO.rx_ind.rx_indication_body.rx_pdu_list   = eNB->rx_pdu_list;
+  eNB->UL_INFO.crc_ind.crc_indication_body.crc_pdu_list = eNB->crc_pdu_list;
+  eNB->UL_INFO.sr_ind.sr_indication_body.sr_pdu_list = eNB->sr_pdu_list;
+  eNB->UL_INFO.harq_ind.harq_indication_body.harq_pdu_list = eNB->harq_pdu_list;
+  eNB->UL_INFO.cqi_ind.cqi_pdu_list = eNB->cqi_pdu_list;
+  eNB->UL_INFO.cqi_ind.cqi_raw_pdu_list = eNB->cqi_raw_pdu_list;
+
+  printf("lte_param_init done\n");
+
   // for a call to phy_reset_ue later we need PHY_vars_UE_g allocated and pointing to UE
   PHY_vars_UE_g = (PHY_VARS_UE***)malloc(sizeof(PHY_VARS_UE**));
   PHY_vars_UE_g[0] = (PHY_VARS_UE**) malloc(sizeof(PHY_VARS_UE*));
@@ -587,7 +758,7 @@ int main(int argc, char **argv)
   if (nb_rb_set == 0)
     nb_rb = eNB->frame_parms.N_RB_UL;
 
-  printf("1 . rxdataF_comp[0] %p\n",eNB->pusch_vars[0]->rxdataF_comp[0][0]);
+  printf("1 . rxdataF_comp[0] %p\n",eNB->pusch_vars[0]->rxdataF_comp[0]);
   printf("Setting mcs = %d\n",mcs);
   printf("n_frames = %d\n", n_frames);
 
@@ -670,7 +841,6 @@ int main(int argc, char **argv)
   eNB->soundingrs_ul_config_dedicated[UE_id].freqDomainPosition = 0;
   eNB->soundingrs_ul_config_dedicated[UE_id].cyclicShift = 0;
 
-  eNB->cooperation_flag = cooperation_flag;
 
   eNB->pusch_config_dedicated[UE_id].betaOffset_ACK_Index = beta_ACK;
   eNB->pusch_config_dedicated[UE_id].betaOffset_RI_Index  = beta_RI;
@@ -700,7 +870,7 @@ int main(int argc, char **argv)
   UE2eNB->max_Doppler = maxDoppler;
 
   // NN: N_RB_UL has to be defined in ulsim
-  eNB->ulsch[0] = new_eNB_ulsch(max_turbo_iterations,N_RB_DL,0);
+  for (int k=0;k<NUMBER_OF_UE_MAX;k++) eNB->ulsch[k] = new_eNB_ulsch(max_turbo_iterations,N_RB_DL,0);
   UE->ulsch[0]   = new_ue_ulsch(N_RB_DL,0);
 
   if (parallel_flag == 1) {
@@ -761,9 +931,9 @@ int main(int argc, char **argv)
   proc_rxtx->subframe_tx=pdcch_alloc2ul_subframe(&eNB->frame_parms,subframe);
 
   proc_rxtx_ue->frame_tx = proc_rxtx->frame_rx;
-  proc_rxtx_ue->frame_rx = proc_rxtx->frame_tx;
+  proc_rxtx_ue->frame_rx = (subframe<4)?(proc_rxtx->frame_tx-1):(proc_rxtx->frame_tx);
   proc_rxtx_ue->subframe_tx = proc_rxtx->subframe_rx;
-  proc_rxtx_ue->subframe_rx = proc_rxtx->subframe_tx;
+  proc_rxtx_ue->subframe_rx = (proc_rxtx->subframe_tx+6)%10;
 
   printf("Init UL hopping UE\n");
   init_ul_hopping(&UE->frame_parms);
@@ -915,7 +1085,6 @@ int main(int argc, char **argv)
       reset_meas(&UE->ulsch_multiplexing_stats);
 
       reset_meas(&eNB->phy_proc_rx);
-      reset_meas(&eNB->ofdm_demod_stats);
       reset_meas(&eNB->ulsch_channel_estimation_stats);
       reset_meas(&eNB->ulsch_freq_offset_estimation_stats);
       reset_meas(&eNB->rx_dft_stats);
@@ -965,19 +1134,38 @@ int main(int argc, char **argv)
         round=0;
 
         while (round < 4) {
+	  proc_rxtx->frame_rx=1;
+	  proc_rxtx->subframe_rx=subframe;
+	  
+	  proc_rxtx->frame_tx=pdcch_alloc2ul_frame(&eNB->frame_parms,1,subframe);
+	  proc_rxtx->subframe_tx=pdcch_alloc2ul_subframe(&eNB->frame_parms,subframe);
+	  
+	  proc_rxtx_ue->frame_tx = proc_rxtx->frame_rx;
+	  proc_rxtx_ue->frame_rx = (subframe<4)?(proc_rxtx->frame_tx-1):(proc_rxtx->frame_tx);
+	  proc_rxtx_ue->subframe_tx = proc_rxtx->subframe_rx;
+	  proc_rxtx_ue->subframe_rx = (proc_rxtx->subframe_tx+6)%10;
+
           eNB->ulsch[0]->harq_processes[harq_pid]->round=round;
           UE->ulsch[0]->harq_processes[harq_pid]->round=round;
-	  //	  printf("Trial %d : Round %d (subframe %d, frame %d)\n",trials,round,proc_rxtx_ue->subframe_rx,proc_rxtx_ue->frame_rx);
+	  if (n_frames==1) printf("filling ulsch: Trial %d : Round %d (subframe %d, frame %d)\n",trials,round,proc_rxtx_ue->subframe_tx,proc_rxtx_ue->frame_tx);
           round_trials[round]++;
 
+	  UL_req.sfn_sf = (1<<4)+subframe;
+	  if (n_frames==1) printf("filling ulsch: eNB prog frame %d, subframe %d (%d,%d)\n",proc_rxtx->frame_rx,subframe,sched_resp.frame,sched_resp.subframe);
 
-	  fill_ulsch_dci(eNB,(void*)&UL_alloc_pdu,first_rb,nb_rb,mcs,ndi,cqi_flag);
+	  int modulation_type;
+	  if (mcs < 11)      modulation_type = 2;
+	  else if (mcs < 21) modulation_type = 4;
+	  else if (mcs < 29) modulation_type = 6;
+ 
+	  fill_ulsch_dci(eNB,proc_rxtx->frame_rx,subframe,&sched_resp,14,(void*)&UL_alloc_pdu,first_rb,nb_rb,(round==0)?mcs:(28+rvidx[round]),modulation_type,ndi,cqi_flag,beta_CQI,beta_RI,cqi_size);
 
 	  UE->ulsch_Msg3_active[eNB_id] = 0;
 	  UE->ul_power_control_dedicated[eNB_id].accumulationEnabled=1;
+	  if (n_frames==1) printf("filling ulsch: ue prog SFN/SF %d/%d\n",proc_rxtx_ue->frame_rx,proc_rxtx_ue->subframe_rx);
 	  generate_ue_ulsch_params_from_dci((void *)&UL_alloc_pdu,
 					    14,
-					    proc_rxtx->subframe_tx,
+					    (subframe+6)%10,
 					    format0,
 					    UE,
 					    proc_rxtx_ue,
@@ -988,17 +1176,11 @@ int main(int argc, char **argv)
 					    0,
 					    srs_flag);
 
-	  generate_eNB_ulsch_params_from_dci(eNB,proc_rxtx,
-					     (void *)&UL_alloc_pdu,
-					     14,
-					     format0,
-					     0,
-					     SI_RNTI,
-					     0,
-					     P_RNTI,
-					     CBA_RNTI,
-					     srs_flag);
-	  eNB->ulsch[0]->harq_processes[harq_pid]->subframe_scheduling_flag = 1;
+	  sched_resp.subframe=(subframe+6)%10;
+	  sched_resp.frame=(1024+eNB->proc.frame_rx+((subframe<4)?-1:0))&1023;
+
+	  schedule_response(&sched_resp);
+
 
           /////////////////////
           if (abstx) {
@@ -1020,6 +1202,9 @@ int main(int argc, char **argv)
 
 	    eNB->proc.frame_rx = 1;
 	    eNB->proc.subframe_rx = subframe;
+	    ru->proc.frame_rx = 1;
+	    ru->proc.subframe_rx = subframe;
+
 	    proc_rxtx_ue->frame_tx = proc_rxtx->frame_rx;
 	    proc_rxtx_ue->frame_rx = proc_rxtx->frame_tx;
 	    proc_rxtx_ue->subframe_tx = proc_rxtx->subframe_rx;
@@ -1027,70 +1212,6 @@ int main(int argc, char **argv)
 
 	    phy_procedures_UE_TX(UE,proc_rxtx_ue,0,0,normal_txrx,no_relay);
 
-	    /*
-            if (srs_flag)
-              generate_srs_tx(UE,0,AMP,subframe);
-
-            generate_drs_pusch(UE,proc_rxtx_ue,0,
-                               AMP,subframe,
-                               UE->ulsch[0]->harq_processes[harq_pid]->first_rb,
-                               UE->ulsch[0]->harq_processes[harq_pid]->nb_rb,
-                               0);
-
-            if ((cqi_flag == 1) && (n_frames == 1) ) {
-              printf("CQI information (O %d) %d %d\n",UE->ulsch[0]->O,
-                     UE->ulsch[0]->o[0],UE->ulsch[0]->o[1]);
-              print_CQI(UE->ulsch[0]->o,UE->ulsch[0]->uci_format,UE->frame_parms.N_RB_DL,0);
-            }
-
-            UE->ulsch[0]->o_ACK[0] = taus()&1;
-
-            start_meas(&UE->ulsch_encoding_stats);
-
-            if (ulsch_encoding(input_buffer,
-                               UE,
-                               harq_pid,
-                               eNB_id,
-                               2, // transmission mode
-                               control_only_flag,
-                               1// Nbundled
-                              )==-1) {
-              printf("ulsim.c Problem with ulsch_encoding\n");
-              exit(-1);
-            }
-
-            stop_meas(&UE->ulsch_encoding_stats);
-
-            start_meas(&UE->ulsch_modulation_stats);
-            ulsch_modulation(UE->common_vars.txdataF,AMP,
-                             proc_rxtx_ue->frame_tx,subframe,&UE->frame_parms,
-                             UE->ulsch[0]);
-            stop_meas(&UE->ulsch_modulation_stats);
-	    */
-
-
-
-
-	    /*
-	    for (aa=0; aa<1; aa++) {
-              if (frame_parms->Ncp == EXTENDED)
-                PHY_ofdm_mod(&UE->common_vars.txdataF[aa][subframe*nsymb*OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES_NO_PREFIX],        // input
-                             &txdata[aa][eNB->frame_parms.samples_per_tti*subframe],         // output
-                             UE->frame_parms.ofdm_symbol_size,
-                             nsymb,                 // number of symbols
-                             UE->frame_parms.nb_prefix_samples,               // number of prefix samples
-                             CYCLIC_PREFIX);
-              else
-                normal_prefix_mod(&UE->common_vars.txdataF[aa][subframe*nsymb*OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES_NO_PREFIX],
-                                  &txdata[aa][eNB->frame_parms.samples_per_tti*subframe],
-                                  nsymb,
-                                  frame_parms);
-
-
-              apply_7_5_kHz(UE,UE->common_vars.txdata[aa],subframe<<1);
-              apply_7_5_kHz(UE,UE->common_vars.txdata[aa],1+(subframe<<1));
-
-*/
 
 	    tx_lev = signal_energy(&UE->common_vars.txdata[0][eNB->frame_parms.samples_per_tti*subframe],
 				   eNB->frame_parms.samples_per_tti);
@@ -1113,11 +1234,11 @@ int main(int argc, char **argv)
 
           //AWGN
           //Set target wideband RX noise level to N0
-          sigma2_dB = N0;//10*log10((double)tx_lev)  +10*log10(UE->frame_parms.ofdm_symbol_size/(UE->frame_parms.N_RB_DL*12)) - SNR;
+          sigma2_dB = N0;//-10*log10(UE->frame_parms.ofdm_symbol_size/(UE->frame_parms.N_RB_DL*12));//10*log10((double)tx_lev)  +10*log10(UE->frame_parms.ofdm_symbol_size/(UE->frame_parms.N_RB_DL*12)) - SNR;
           sigma2 = pow(10,sigma2_dB/10);
 
           // compute tx_gain to achieve target SNR (per resource element!)
-          tx_gain = sqrt(pow(10.0,.1*(N0+SNR))*(nb_rb*12/(double)UE->frame_parms.ofdm_symbol_size)/(double)tx_lev);
+          tx_gain = sqrt(pow(10.0,.1*(N0+SNR))/(double)tx_lev);//*(nb_rb*12/(double)UE->frame_parms.ofdm_symbol_size)/(double)tx_lev);
 
 
 	  if (n_frames==1)
@@ -1128,8 +1249,8 @@ int main(int argc, char **argv)
           for (i=0; i<OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES; i++) {
             for (aa=0; aa<eNB->frame_parms.nb_antennas_rx; aa++) {
 
-              ((short*) &eNB->common_vars.rxdata[0][aa][(frame_parms->samples_per_tti<<1) -frame_parms->ofdm_symbol_size])[2*i] = (short) ((sqrt(sigma2/2)*gaussdouble(0.0,1.0)));
-              ((short*) &eNB->common_vars.rxdata[0][aa][(frame_parms->samples_per_tti<<1) -frame_parms->ofdm_symbol_size])[2*i+1] = (short) ((sqrt(sigma2/2)*gaussdouble(0.0,1.0)));
+              ((short*) &ru->common.rxdata[aa][(frame_parms->samples_per_tti<<1) -frame_parms->ofdm_symbol_size])[2*i] = (short) ((sqrt(sigma2/2)*gaussdouble(0.0,1.0)));
+              ((short*) &ru->common.rxdata[aa][(frame_parms->samples_per_tti<<1) -frame_parms->ofdm_symbol_size])[2*i+1] = (short) ((sqrt(sigma2/2)*gaussdouble(0.0,1.0)));
             }
           }
 
@@ -1186,37 +1307,37 @@ int main(int argc, char **argv)
 
           for (i=0; i<eNB->frame_parms.samples_per_tti; i++) {
             for (aa=0; aa<eNB->frame_parms.nb_antennas_rx; aa++) {
-              ((short*) &eNB->common_vars.rxdata[0][aa][eNB->frame_parms.samples_per_tti*subframe])[2*i] = (short) ((tx_gain*r_re[aa][i]) + sqrt(sigma2/2)*gaussdouble(0.0,1.0));
-              ((short*) &eNB->common_vars.rxdata[0][aa][eNB->frame_parms.samples_per_tti*subframe])[2*i+1] = (short) ((tx_gain*r_im[aa][i]) + (iqim*tx_gain*r_re[aa][i]) + sqrt(
+              ((short*) &ru->common.rxdata[aa][eNB->frame_parms.samples_per_tti*subframe])[2*i] = (short) ((tx_gain*r_re[aa][i]) + sqrt(sigma2/2)*gaussdouble(0.0,1.0));
+              ((short*) &ru->common.rxdata[aa][eNB->frame_parms.samples_per_tti*subframe])[2*i+1] = (short) ((tx_gain*r_im[aa][i]) + (iqim*tx_gain*r_re[aa][i]) + sqrt(
                     sigma2/2)*gaussdouble(0.0,1.0));
             }
           }
 
-          if (n_frames==1) {
+          if (n_frames<=10) {
             printf("rx_level Null symbol %f\n",10*log10((double)signal_energy((int*)
-                   &eNB->common_vars.rxdata[0][0][(eNB->frame_parms.samples_per_tti<<1) -eNB->frame_parms.ofdm_symbol_size],OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2)));
-            printf("rx_level data symbol %f\n",10*log10(signal_energy((int*)&eNB->common_vars.rxdata[0][0][160+(eNB->frame_parms.samples_per_tti*subframe)],
+                   &ru->common.rxdata[0][(eNB->frame_parms.samples_per_tti<<1) -eNB->frame_parms.ofdm_symbol_size],OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2)));
+            printf("rx_level data symbol %f\n",10*log10(signal_energy((int*)&ru->common.rxdata[0][160+(eNB->frame_parms.samples_per_tti*subframe)],
                    OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2)));
           }
 
-          SNRmeas = 10*log10(((double)signal_energy((int*)&eNB->common_vars.rxdata[0][0][160+(eNB->frame_parms.samples_per_tti*subframe)],
+          SNRmeas = 10*log10(((double)signal_energy((int*)&ru->common.rxdata[0][160+(eNB->frame_parms.samples_per_tti*subframe)],
                               OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2))/((double)signal_energy((int*)
-                                  &eNB->common_vars.rxdata[0][0][(eNB->frame_parms.samples_per_tti<<1) -eNB->frame_parms.ofdm_symbol_size],
+                                  &ru->common.rxdata[0][(eNB->frame_parms.samples_per_tti<<1) -eNB->frame_parms.ofdm_symbol_size],
                                   OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2)) - 1)+10*log10(eNB->frame_parms.N_RB_UL/nb_rb);
 
-          if (n_frames==1) {
+          if (n_frames<=10) {
             printf("SNRmeas %f\n",SNRmeas);
 
-            //    write_output("rxsig0UL.m","rxs0", &eNB->common_vars.rxdata[0][0][eNB->frame_parms.samples_per_tti*subframe],eNB->frame_parms.samples_per_tti,1,1);
-            //write_output("rxsig1UL.m","rxs1", &eNB->common_vars.rxdata[0][0][eNB->frame_parms.samples_per_tti*subframe],eNB->frame_parms.samples_per_tti,1,1);
+	    write_output("rxsig0UL.m","rxs0", &ru->common.rxdata[0][eNB->frame_parms.samples_per_tti*subframe],eNB->frame_parms.samples_per_tti,1,1);
+	    //            write_output("rxsig1UL.m","rxs1", &ru->common_vars.rxdata[0][eNB->frame_parms.samples_per_tti*subframe],eNB->frame_parms.samples_per_tti,1,1);
           }
 
 
-	  eNB->fep = (parallel_flag == 1) ? eNB_fep_full_2thread        : eNB_fep_full;
+	  ru->feprx = (parallel_flag == 1) ? ru_fep_full_2thread        : fep_full;
 	  eNB->td  = (parallel_flag == 1) ? ulsch_decoding_data_2thread : ulsch_decoding_data;
-	  eNB->do_prach = NULL;
 
-	  phy_procedures_eNB_common_RX(eNB,proc_rxtx);
+	  
+	  ru->feprx(ru);
 	  phy_procedures_eNB_uespec_RX(eNB,proc_rxtx,no_relay);
 
 
@@ -1252,7 +1373,7 @@ int main(int argc, char **argv)
 	  
 	  //          if (ret <= eNB->ulsch[0]->max_turbo_iterations) {
 	  
-	  if (eNB->ulsch[0]->harq_processes[harq_pid]->round == 0) {
+	  if (eNB->ulsch[0]->harq_processes[harq_pid]->status == SCH_IDLE) { 
 
 	    //  avg_iter += ret;
 	    iter_trials++;
@@ -1264,7 +1385,7 @@ int main(int argc, char **argv)
                 print_CQI(eNB->ulsch[0]->harq_processes[harq_pid]->o,
                           eNB->ulsch[0]->harq_processes[harq_pid]->uci_format,0,eNB->frame_parms.N_RB_DL);
 
-              dump_ulsch(eNB,proc_rxtx,0);
+              dump_ulsch(eNB,eNB->proc.frame_rx,subframe,0,round);
               exit(-1);
             }
 
@@ -1293,11 +1414,11 @@ int main(int argc, char **argv)
                          eNB->ulsch[0]->harq_processes[harq_pid]->c[s][i]^UE->ulsch[0]->harq_processes[harq_pid]->c[s][i]);
               }
 
-              dump_ulsch(eNB,proc_rxtx,0);
-              exit(-1);
+              dump_ulsch(eNB,eNB->proc.frame_rx,subframe,0,round);
+              if (round == 4) exit(-1);
             }
 
-            //      printf("round %d errors %d/%d\n",round,errs[round],trials);
+	    if (n_frames==1) printf("round %d errors %d/%d\n",round,errs[round],trials);
             round++;
 
             if (n_frames==1) {
@@ -1305,7 +1426,6 @@ int main(int argc, char **argv)
             }
           }  // ulsch error	  
 
-
         } // round
 
         //      printf("\n");
@@ -1324,7 +1444,7 @@ int main(int argc, char **argv)
 
 
         double t_rx = (double)eNB->phy_proc_rx.p_time/cpu_freq_GHz/1000.0;
-        double t_rx_fft = (double)eNB->ofdm_demod_stats.p_time/cpu_freq_GHz/1000.0;
+        double t_rx_fft = (double)ru->ofdm_demod_stats.p_time/cpu_freq_GHz/1000.0;
         double t_rx_demod = (double)eNB->ulsch_demodulation_stats.p_time/cpu_freq_GHz/1000.0;
         double t_rx_dec = (double)eNB->ulsch_decoding_stats.p_time/cpu_freq_GHz/1000.0;
 
@@ -1449,12 +1569,12 @@ int main(int argc, char **argv)
              tx_lev_dB,
              20*log10(tx_gain),
              (double)N0,
-             eNB->measurements[0].n0_power_tot_dB,
+             eNB->measurements.n0_power_tot_dB,
              get_hundred_times_delta_IF(UE,eNB_id,harq_pid) ,
              dB_fixed(eNB->pusch_vars[0]->ulsch_power[0]),
              dB_fixed(eNB->pusch_vars[0]->ulsch_power[1]),
-             eNB->measurements->n0_power_dB[0],
-             eNB->measurements->n0_power_dB[1]);
+             eNB->measurements.n0_power_dB[0],
+             eNB->measurements.n0_power_dB[1]);
 
       effective_rate = ((double)(round_trials[0])/((double)round_trials[0] + round_trials[1] + round_trials[2] + round_trials[3]));
 
@@ -1548,10 +1668,10 @@ int main(int argc, char **argv)
         printf("Total PHY proc rx                  :%f us (%d trials)\n",(double)eNB->phy_proc_rx.diff/eNB->phy_proc_rx.trials/cpu_freq_GHz/1000.0,eNB->phy_proc_rx.trials);
         printf("|__ Statistcs                           std: %fus max: %fus min: %fus median %fus q1 %fus q3 %fus n_dropped: %d packet \n", std_phy_proc_rx, t_rx_max, t_rx_min, rx_median, rx_q1, rx_q3,
                n_rx_dropped);
-        std_phy_proc_rx_fft = sqrt((double)eNB->ofdm_demod_stats.diff_square/pow(cpu_freq_GHz,2)/pow(1000,
-                                   2)/eNB->ofdm_demod_stats.trials - pow((double)eNB->ofdm_demod_stats.diff/eNB->ofdm_demod_stats.trials/cpu_freq_GHz/1000,2));
-        printf("OFDM_demod time                   :%f us (%d trials)\n",(double)eNB->ofdm_demod_stats.diff/eNB->ofdm_demod_stats.trials/cpu_freq_GHz/1000.0,
-               eNB->ofdm_demod_stats.trials);
+        std_phy_proc_rx_fft = sqrt((double)ru->ofdm_demod_stats.diff_square/pow(cpu_freq_GHz,2)/pow(1000,
+                                   2)/ru->ofdm_demod_stats.trials - pow((double)ru->ofdm_demod_stats.diff/ru->ofdm_demod_stats.trials/cpu_freq_GHz/1000,2));
+        printf("OFDM_demod time                   :%f us (%d trials)\n",(double)ru->ofdm_demod_stats.diff/ru->ofdm_demod_stats.trials/cpu_freq_GHz/1000.0,
+               ru->ofdm_demod_stats.trials);
         printf("|__ Statistcs                           std: %fus median %fus q1 %fus q3 %fus \n", std_phy_proc_rx_fft, rx_fft_median, rx_fft_q1, rx_fft_q3);
         std_phy_proc_rx_demod = sqrt((double)eNB->ulsch_demodulation_stats.diff_square/pow(cpu_freq_GHz,2)/pow(1000,
                                      2)/eNB->ulsch_demodulation_stats.trials - pow((double)eNB->ulsch_demodulation_stats.diff/eNB->ulsch_demodulation_stats.trials/cpu_freq_GHz/1000,2));
@@ -1672,7 +1792,7 @@ int main(int argc, char **argv)
                 UE->ulsch_modulation_stats.trials,
                 UE->ulsch_encoding_stats.trials,
                 eNB->phy_proc_rx.trials,
-                eNB->ofdm_demod_stats.trials,
+                ru->ofdm_demod_stats.trials,
                 eNB->ulsch_demodulation_stats.trials,
                 eNB->ulsch_decoding_stats.trials
                );
@@ -1682,7 +1802,7 @@ int main(int argc, char **argv)
                 get_time_meas_us(&UE->ulsch_modulation_stats),
                 get_time_meas_us(&UE->ulsch_encoding_stats),
                 get_time_meas_us(&eNB->phy_proc_rx),
-                get_time_meas_us(&eNB->ofdm_demod_stats),
+                get_time_meas_us(&ru->ofdm_demod_stats),
                 get_time_meas_us(&eNB->ulsch_demodulation_stats),
                 get_time_meas_us(&eNB->ulsch_decoding_stats)
                );
@@ -1733,7 +1853,7 @@ int main(int argc, char **argv)
 
 
   oai_exit=1;
-  pthread_cond_signal(&eNB->proc.cond_fep);
+  pthread_cond_signal(&ru->proc.cond_fep);
 
   if (abstx) { // ABSTRACTION
     fprintf(csv_fdUL,"];");