Resolving some problems with Gain Control for Full physical emulation in frequency domain

openair1/PHY/LTE_ESTIMATION/adjust_gain.c

@@ -27,7 +27,8 @@ void
 phy_adjust_gain (PHY_VARS_UE *ue, uint32_t rx_power_fil_dB, uint8_t eNB_id)
 {
 
-  LOG_D(PHY,"Gain control: rssi %d (%d,%d)\n",
+  LOG_D(PHY,"[UE %d] Gain control: rssi %d (%d,%d)\n",
+	ue->Mod_id,
 	rx_power_fil_dB,
 	ue->measurements.rssi,
 	ue->measurements.rx_power_avg_dB[eNB_id]
@@ -61,7 +62,7 @@ phy_adjust_gain (PHY_VARS_UE *ue, uint32_t rx_power_fil_dB, uint8_t eNB_id)
     ue->rx_total_gain_dB = MIN_RF_GAIN;
   }
 
-  LOG_D(PHY,"Gain control: rx_total_gain_dB = %d (max %d,rxpf %d)\n",ue->rx_total_gain_dB,MAX_RF_GAIN,rx_power_fil_dB);
+  LOG_D(PHY,"[UE %d] Gain control: rx_total_gain_dB = %d (max %d,rxpf %d)\n",ue->Mod_id,ue->rx_total_gain_dB,MAX_RF_GAIN,rx_power_fil_dB);
 
 #ifdef DEBUG_PHY
   /*  if ((ue->frame%100==0) || (ue->frame < 10))

openair1/PHY/LTE_ESTIMATION/defs.h

@@ -214,6 +214,13 @@ void lte_ue_measurements(PHY_VARS_UE *phy_vars_ue,
                          unsigned char rank_adaptation,
                          uint8_t subframe);
 
+void lte_ue_measurements_freq(PHY_VARS_UE *phy_vars_ue,
+                         unsigned int subframe_offset,
+                         unsigned char N0_symbol,
+                         unsigned char abstraction_flag,
+                         unsigned char rank_adaptation,
+                         uint8_t subframe);
+
 //! \brief This function performance RSRP/RSCP measurements
 void ue_rrc_measurements(PHY_VARS_UE *phy_vars_ue,
                          uint8_t slot,

openair1/PHY/LTE_ESTIMATION/lte_dl_channel_estimation.c

@@ -841,9 +841,9 @@ int lte_dl_channel_estimation_freq(PHY_VARS_UE *ue,
 
   uint8_t nushift,pilot0,pilot1,pilot2,pilot3;
   uint8_t previous_thread_id = ue->current_thread_id[Ns>>1]==0 ? (RX_NB_TH-1):(ue->current_thread_id[Ns>>1]-1);
-  int **dl_ch_estimates         =ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[Ns>>1]].dl_ch_estimates[eNB_offset];
-  int **dl_ch_estimates_previous=ue->common_vars.common_vars_rx_data_per_thread[previous_thread_id].dl_ch_estimates[eNB_offset];
-  int **rxdataF=ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[Ns>>1]].rxdataF;
+  int **dl_ch_estimates         =ue->common_vars.common_vars_rx_data_per_thread[(Ns>>1)&0x1].dl_ch_estimates[eNB_offset];
+  int **dl_ch_estimates_previous=ue->common_vars.common_vars_rx_data_per_thread[((Ns>>1)&0x1)==1?1:0].dl_ch_estimates[eNB_offset];
+  int **rxdataF=ue->common_vars.common_vars_rx_data_per_thread[(Ns>>1)&0x1].rxdataF;
 
   int subframe = Ns>>1;
   pilot0 = 0;
@@ -885,7 +885,7 @@ int lte_dl_channel_estimation_freq(PHY_VARS_UE *ue,
   k = (nu + nushift)%6;
 
 #ifdef DEBUG_CH
-  printf("Channel Estimation : ThreadId %d, eNB_offset %d cell_id %d ch_offset %d, OFDM size %d, Ncp=%d, l=%d, Ns=%d, k=%d\n",ue->current_thread_id[Ns>>1], eNB_offset,Nid_cell,ch_offset,ue->frame_parms.ofdm_symbol_size,
+  printf("Channel Estimation : ThreadId %d, eNB_offset %d cell_id %d ch_offset %d, OFDM size %d, Ncp=%d, l=%d, Ns=%d, k=%d\n",(Ns>>1)&0x1, eNB_offset,Nid_cell,ch_offset,ue->frame_parms.ofdm_symbol_size,
          ue->frame_parms.Ncp,l,Ns,k);
 #endif
 

openair1/PHY/LTE_ESTIMATION/lte_dl_mbsfn_channel_estimation.c

@@ -787,8 +787,8 @@ int lte_dl_mbsfn_channel_estimation_freq(PHY_VARS_UE *ue,
   //  unsigned int n;
   //  int i;
 
-  int **dl_ch_estimates=ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates[0];
-  int **rxdataF=ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF;
+  int **dl_ch_estimates=ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[0];
+  int **rxdataF=ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF;
 
   ch_offset     = (l*(ue->frame_parms.ofdm_symbol_size));
   symbol_offset = ch_offset;//phy_vars_ue->lte_frame_parms.ofdm_symbol_size*l;

openair1/PHY/LTE_ESTIMATION/lte_sync_time.c

@@ -498,7 +498,164 @@ int lte_sync_time(int **rxdata, ///rx data in time domain
   return(peak_pos);
 
 }
+int lte_sync_freq(int **rxdataF, ///rx data in frequency domain
+                  LTE_DL_FRAME_PARMS *frame_parms,
+                  int *eNB_id)
+{
+
+
+
+  // perform a frequency domain correlation using the oversampled sync sequence
+
+  unsigned int n, ar, s, peak_pos, peak_val, sync_source;
+  int result,result2;
+  int sync_out[3] = {0,0,0},sync_out2[3] = {0,0,0};
+  int tmp[3] = {0,0,0};
+  int length =   LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti>>1;
+
+  //msg("[SYNC TIME] Calling sync_time.\n");
+  if (sync_corr_ue0 == NULL) {
+    msg("[SYNC TIME] sync_corr_ue0 not yet allocated! Exiting.\n");
+    return(-1);
+  }
+
+  if (sync_corr_ue1 == NULL) {
+    msg("[SYNC TIME] sync_corr_ue1 not yet allocated! Exiting.\n");
+    return(-1);
+  }
+
+  if (sync_corr_ue2 == NULL) {
+    msg("[SYNC TIME] sync_corr_ue2 not yet allocated! Exiting.\n");
+    return(-1);
+  }
+
+  peak_val = 0;
+  peak_pos = 0;
+  sync_source = 0;
+
+
+  for (n=0; n<length; n+=4) {
+
+#ifdef RTAI_ENABLED
+
+    // This is necessary since the sync takes a long time and it seems to block all other threads thus screwing up RTAI. If we pause it for a little while during its execution we give RTAI a chance to catch up with its other tasks.
+    if ((n%(frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti) == 0) && (n>0) && (openair_daq_vars.sync_state==0)) {
+#ifdef DEBUG_PHY
+      msg("[SYNC FREQ] pausing for 1000ns, n=%d\n",n);
+#endif
+      rt_sleep(nano2count(1000));
+    }
+
+#endif
+
+    sync_corr_ue0[n] = 0;
+    sync_corr_ue0[n+length] = 0;
+    sync_corr_ue1[n] = 0;
+    sync_corr_ue1[n+length] = 0;
+    sync_corr_ue2[n] = 0;
+    sync_corr_ue2[n+length] = 0;
+
+    for (s=0; s<3; s++) {
+      sync_out[s]=0;
+      sync_out2[s]=0;
+    }
+
+    //    if (n<(length-frame_parms->ofdm_symbol_size-frame_parms->nb_prefix_samples)) {
+    if (n<(length-frame_parms->ofdm_symbol_size)) {
+
+      //calculate dot product of primary_synch0_time and rxdataF[ar][n] (ar=0..nb_ant_rx) and store the sum in temp[n];
+      for (ar=0; ar<frame_parms->nb_antennas_rx; ar++) {
+
+        result  = dot_product((short*)primary_synch0_time, (short*) &(rxdataF[ar][n]), frame_parms->ofdm_symbol_size, SHIFT);
+        result2 = dot_product((short*)primary_synch0_time, (short*) &(rxdataF[ar][n+length]), frame_parms->ofdm_symbol_size, SHIFT);
+
+        ((short*)sync_corr_ue0)[2*n] += ((short*) &result)[0];
+        ((short*)sync_corr_ue0)[2*n+1] += ((short*) &result)[1];
+        ((short*)sync_corr_ue0)[2*(length+n)] += ((short*) &result2)[0];
+        ((short*)sync_corr_ue0)[(2*(length+n))+1] += ((short*) &result2)[1];
+        ((short*)sync_out)[0] += ((short*) &result)[0];
+        ((short*)sync_out)[1] += ((short*) &result)[1];
+        ((short*)sync_out2)[0] += ((short*) &result2)[0];
+        ((short*)sync_out2)[1] += ((short*) &result2)[1];
+      }
 
+      for (ar=0; ar<frame_parms->nb_antennas_rx; ar++) {
+        result = dot_product((short*)primary_synch1_time, (short*) &(rxdataF[ar][n]), frame_parms->ofdm_symbol_size, SHIFT);
+        result2 = dot_product((short*)primary_synch1_time, (short*) &(rxdataF[ar][n+length]), frame_parms->ofdm_symbol_size, SHIFT);
+        ((short*)sync_corr_ue1)[2*n] += ((short*) &result)[0];
+        ((short*)sync_corr_ue1)[2*n+1] += ((short*) &result)[1];
+        ((short*)sync_corr_ue1)[2*(length+n)] += ((short*) &result2)[0];
+        ((short*)sync_corr_ue1)[(2*(length+n))+1] += ((short*) &result2)[1];
+
+        ((short*)sync_out)[2] += ((short*) &result)[0];
+        ((short*)sync_out)[3] += ((short*) &result)[1];
+        ((short*)sync_out2)[2] += ((short*) &result2)[0];
+        ((short*)sync_out2)[3] += ((short*) &result2)[1];
+      }
+
+      for (ar=0; ar<frame_parms->nb_antennas_rx; ar++) {
+
+        result = dot_product((short*)primary_synch2_time, (short*) &(rxdataF[ar][n]), frame_parms->ofdm_symbol_size, SHIFT);
+        result2 = dot_product((short*)primary_synch2_time, (short*) &(rxdataF[ar][n+length]), frame_parms->ofdm_symbol_size, SHIFT);
+        ((short*)sync_corr_ue2)[2*n] += ((short*) &result)[0];
+        ((short*)sync_corr_ue2)[2*n+1] += ((short*) &result)[1];
+        ((short*)sync_corr_ue2)[2*(length+n)] += ((short*) &result2)[0];
+        ((short*)sync_corr_ue2)[(2*(length+n))+1] += ((short*) &result2)[1];
+        ((short*)sync_out)[4] += ((short*) &result)[0];
+        ((short*)sync_out)[5] += ((short*) &result)[1];
+        ((short*)sync_out2)[4] += ((short*) &result2)[0];
+        ((short*)sync_out2)[5] += ((short*) &result2)[1];
+      }
+
+    }
+
+    // calculate the absolute value of sync_corr[n]
+
+    sync_corr_ue0[n] = abs32(sync_corr_ue0[n]);
+    sync_corr_ue0[n+length] = abs32(sync_corr_ue0[n+length]);
+    sync_corr_ue1[n] = abs32(sync_corr_ue1[n]);
+    sync_corr_ue1[n+length] = abs32(sync_corr_ue1[n+length]);
+    sync_corr_ue2[n] = abs32(sync_corr_ue2[n]);
+    sync_corr_ue2[n+length] = abs32(sync_corr_ue2[n+length]);
+
+    for (s=0; s<3; s++) {
+      tmp[s] = (abs32(sync_out[s])>>1) + (abs32(sync_out2[s])>>1);
+
+      if (tmp[s]>peak_val) {
+        peak_val = tmp[s];
+        peak_pos = n;
+        sync_source = s;
+        /*
+        printf("s %d: n %d sync_out %d, sync_out2  %d (sync_corr %d,%d), (%d,%d) (%d,%d)\n",s,n,abs32(sync_out[s]),abs32(sync_out2[s]),sync_corr_ue0[n],
+               sync_corr_ue0[n+length],((int16_t*)&sync_out[s])[0],((int16_t*)&sync_out[s])[1],((int16_t*)&sync_out2[s])[0],((int16_t*)&sync_out2[s])[1]);
+        */
+      }
+    }
+  }
+
+  *eNB_id = sync_source;
+
+  LOG_D(PHY,"[UE] lte_sync_time: Sync source = %d, Peak found at pos %d, val = %d (%d dB)\n",sync_source,peak_pos,peak_val,dB_fixed(peak_val)/2);
+
+
+#ifdef DEBUG_PHY
+  if (debug_cnt == 0) {
+    write_output("sync_corr0_ue.m","synccorr0",sync_corr_ue0,2*length,1,2);
+    write_output("sync_corr1_ue.m","synccorr1",sync_corr_ue1,2*length,1,2);
+    write_output("sync_corr2_ue.m","synccorr2",sync_corr_ue2,2*length,1,2);
+    write_output("rxdata0.m","rxd0",rxdataF[0],length<<1,1,1);
+    //    exit(-1);
+  } else {
+    debug_cnt++;
+  }
+
+
+#endif
+
+
+  return(peak_pos);
+
+}
 //#define DEBUG_PHY
 
 int lte_sync_time_eNB(int32_t **rxdata, ///rx data in time domain

openair1/PHY/LTE_TRANSPORT/pbch.c

@@ -519,6 +519,106 @@ uint16_t pbch_extract(int **rxdataF,
   return(0);
 }
 
+uint16_t pbch_extract_freq(int **rxdataF,
+                      int **dl_ch_estimates,
+                      int **rxdataF_ext,
+                      int **dl_ch_estimates_ext,
+                      uint32_t symbol,
+                      uint32_t high_speed_flag,
+                      LTE_DL_FRAME_PARMS *frame_parms,
+		      uint16_t subframe)
+{
+
+
+  uint16_t rb,nb_rb=6;
+  uint8_t i,j,aarx,aatx;
+  int *dl_ch0,*dl_ch0_ext,*rxF,*rxF_ext;
+
+  uint32_t nsymb = (frame_parms->Ncp==0) ? 7:6;
+  uint32_t symbol_mod = symbol % nsymb;
+
+  int rx_offset = frame_parms->ofdm_symbol_size-3*12;
+  int ch_offset = frame_parms->N_RB_DL*6-3*12;
+  int nushiftmod3 = frame_parms->nushift%3;
+
+  for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+    /*
+    printf("extract_rbs (nushift %d): symbol_mod=%d, rx_offset=%d, ch_offset=%d\n",frame_parms->nushift,symbol_mod,
+     (rx_offset + (symbol*(frame_parms->ofdm_symbol_size)))*2,
+     LTE_CE_OFFSET+ch_offset+(symbol_mod*(frame_parms->ofdm_symbol_size)));
+    */
+
+    rxF        = &rxdataF[aarx][(rx_offset + (symbol*(frame_parms->ofdm_symbol_size)))+subframe*(frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti)];
+    rxF_ext    = &rxdataF_ext[aarx][symbol_mod*(6*12)];
+
+    for (rb=0; rb<nb_rb; rb++) {
+      // skip DC carrier
+      if (rb==3) {
+        rxF       = &rxdataF[aarx][(1 + (symbol*(frame_parms->ofdm_symbol_size)))+subframe*(frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti)];
+      }
+
+      if ((symbol_mod==0) || (symbol_mod==1)) {
+        j=0;
+
+        for (i=0; i<12; i++) {
+          if ((i!=nushiftmod3) &&
+              (i!=(nushiftmod3+3)) &&
+              (i!=(nushiftmod3+6)) &&
+              (i!=(nushiftmod3+9))) {
+            rxF_ext[j++]=rxF[i];
+          }
+        }
+
+        rxF+=12;
+        rxF_ext+=8;
+      } else {
+        for (i=0; i<12; i++) {
+          rxF_ext[i]=rxF[i];
+        }
+
+        rxF+=12;
+        rxF_ext+=12;
+      }
+    }
+
+    for (aatx=0; aatx<4; aatx++) { //frame_parms->nb_antenna_ports_eNB;aatx++) {
+      if (high_speed_flag == 1)
+        dl_ch0     = &dl_ch_estimates[(aatx<<1)+aarx][LTE_CE_OFFSET+ch_offset+(symbol*(frame_parms->ofdm_symbol_size))];
+      else
+        dl_ch0     = &dl_ch_estimates[(aatx<<1)+aarx][LTE_CE_OFFSET+ch_offset];
+
+      dl_ch0_ext = &dl_ch_estimates_ext[(aatx<<1)+aarx][symbol_mod*(6*12)];
+
+      for (rb=0; rb<nb_rb; rb++) {
+        // skip DC carrier
+        // if (rb==3) dl_ch0++;
+        if (symbol_mod>1) {
+          memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int));
+          dl_ch0+=12;
+          dl_ch0_ext+=12;
+        } else {
+          j=0;
+
+          for (i=0; i<12; i++) {
+            if ((i!=nushiftmod3) &&
+                (i!=(nushiftmod3+3)) &&
+                (i!=(nushiftmod3+6)) &&
+                (i!=(nushiftmod3+9))) {
+              //        printf("PBCH extract i %d j %d => (%d,%d)\n",i,j,*(short *)&dl_ch0[i],*(1+(short*)&dl_ch0[i]));
+              dl_ch0_ext[j++]=dl_ch0[i];
+            }
+          }
+
+          dl_ch0+=12;
+          dl_ch0_ext+=8;
+        }
+      }
+    }  //tx antenna loop
+
+  }
+
+  return(0);
+}
 //__m128i avg128;
 
 //compute average channel_level on each (TX,RX) antenna pair
@@ -999,6 +1099,187 @@ uint16_t rx_pbch(LTE_UE_COMMON *lte_ue_common_vars,
 
 
 
+  phy_viterbi_lte_sse2(pbch_d_rx+96,pbch_a,16+PBCH_A);
+
+  // Fix byte endian of PBCH (bit 23 goes in first)
+  for (i=0; i<(PBCH_A>>3); i++)
+    decoded_output[(PBCH_A>>3)-i-1] = pbch_a[i];
+
+#ifdef DEBUG_PBCH
+
+  for (i=0; i<(PBCH_A>>3); i++)
+    msg("[PBCH] pbch_a[%d] = %x\n",i,decoded_output[i]);
+
+#endif //DEBUG_PBCH
+
+#ifdef DEBUG_PBCH
+  msg("PBCH CRC %x : %x\n",
+      crc16(pbch_a,PBCH_A),
+      ((uint16_t)pbch_a[PBCH_A>>3]<<8)+pbch_a[(PBCH_A>>3)+1]);
+#endif
+
+  crc = (crc16(pbch_a,PBCH_A)>>16) ^
+        (((uint16_t)pbch_a[PBCH_A>>3]<<8)+pbch_a[(PBCH_A>>3)+1]);
+
+  if (crc == 0x0000)
+  {
+    return(1);
+  }
+  else if (crc == 0xffff)
+  {
+    return(2);
+  }
+  else if (crc == 0x5555)
+  {
+    return(4);
+  }
+  else
+  {
+    return(-1);
+  }
+
+}
+
+uint16_t rx_pbch_freq(LTE_UE_COMMON *lte_ue_common_vars,
+                 LTE_UE_PBCH *lte_ue_pbch_vars,
+                 LTE_DL_FRAME_PARMS *frame_parms,
+                 uint8_t eNB_id,
+                 MIMO_mode_t mimo_mode,
+                 uint32_t high_speed_flag,
+                 uint8_t frame_mod4,
+		 uint16_t subframe)
+{
+
+  uint8_t log2_maxh;//,aatx,aarx;
+  int max_h=0;
+
+  int symbol,i;
+  uint32_t nsymb = (frame_parms->Ncp==0) ? 14:12;
+  uint16_t  pbch_E;
+  uint8_t pbch_a[8];
+  uint8_t RCC;
+
+  int8_t *pbch_e_rx;
+  uint8_t *decoded_output = lte_ue_pbch_vars->decoded_output;
+  uint16_t crc;
+
+
+  //  pbch_D    = 16+PBCH_A;
+
+  pbch_E  = (frame_parms->Ncp==0) ? 1920 : 1728; //RE/RB * #RB * bits/RB (QPSK)
+  pbch_e_rx = &lte_ue_pbch_vars->llr[frame_mod4*(pbch_E>>2)];
+#ifdef DEBUG_PBCH
+  msg("[PBCH] starting symbol loop (Ncp %d, frame_mod4 %d,mimo_mode %d\n",frame_parms->Ncp,frame_mod4,mimo_mode);
+#endif
+
+  // clear LLR buffer
+  memset(lte_ue_pbch_vars->llr,0,pbch_E);
+
+  for (symbol=(nsymb>>1); symbol<(nsymb>>1)+4; symbol++) {
+
+#ifdef DEBUG_PBCH
+    msg("[PBCH] starting extract\n");
+#endif
+    pbch_extract_freq(lte_ue_common_vars->common_vars_rx_data_per_thread[0].rxdataF,
+                 lte_ue_common_vars->common_vars_rx_data_per_thread[0].dl_ch_estimates[eNB_id],
+                 lte_ue_pbch_vars->rxdataF_ext,
+                 lte_ue_pbch_vars->dl_ch_estimates_ext,
+                 symbol,
+                 high_speed_flag,
+                 frame_parms,
+		 subframe);
+#ifdef DEBUG_PBCH
+    msg("[PHY] PBCH Symbol %d\n",symbol);
+    msg("[PHY] PBCH starting channel_level\n");
+#endif
+
+    max_h = pbch_channel_level(lte_ue_pbch_vars->dl_ch_estimates_ext,
+                               frame_parms,
+                               symbol);
+    log2_maxh = 3+(log2_approx(max_h)/2);
+
+#ifdef DEBUG_PBCH
+    msg("[PHY] PBCH log2_maxh = %d (%d)\n",log2_maxh,max_h);
+#endif
+
+    pbch_channel_compensation(lte_ue_pbch_vars->rxdataF_ext,
+                              lte_ue_pbch_vars->dl_ch_estimates_ext,
+                              lte_ue_pbch_vars->rxdataF_comp,
+                              frame_parms,
+                              symbol,
+                              log2_maxh); // log2_maxh+I0_shift
+
+    if (frame_parms->nb_antennas_rx > 1)
+      pbch_detection_mrc(frame_parms,
+                         lte_ue_pbch_vars->rxdataF_comp,
+                         symbol);
+
+
+    if (mimo_mode == ALAMOUTI) {
+      pbch_alamouti(frame_parms,lte_ue_pbch_vars->rxdataF_comp,symbol);
+      //  msg("[PBCH][RX] Alamouti receiver not yet implemented!\n");
+      //  return(-1);
+    } else if (mimo_mode != SISO) {
+      msg("[PBCH][RX] Unsupported MIMO mode\n");
+      return(-1);
+    }
+
+    if (symbol>(nsymb>>1)+1) {
+      pbch_quantize(pbch_e_rx,
+                    (short*)&(lte_ue_pbch_vars->rxdataF_comp[0][(symbol%(nsymb>>1))*72]),
+                    144);
+
+      pbch_e_rx+=144;
+    } else {
+      pbch_quantize(pbch_e_rx,
+                    (short*)&(lte_ue_pbch_vars->rxdataF_comp[0][(symbol%(nsymb>>1))*72]),
+                    96);
+
+      pbch_e_rx+=96;
+    }
+
+
+  }
+
+  pbch_e_rx = lte_ue_pbch_vars->llr;
+
+
+
+  //un-scrambling
+#ifdef DEBUG_PBCH
+  msg("[PBCH] doing unscrambling\n");
+#endif
+
+
+  pbch_unscrambling(frame_parms,
+                    pbch_e_rx,
+                    pbch_E,
+                    frame_mod4);
+
+
+
+  //un-rate matching
+#ifdef DEBUG_PBCH
+  msg("[PBCH] doing un-rate-matching\n");
+#endif
+
+
+  memset(dummy_w_rx,0,3*3*(16+PBCH_A));
+  RCC = generate_dummy_w_cc(16+PBCH_A,
+                            dummy_w_rx);
+
+
+  lte_rate_matching_cc_rx(RCC,pbch_E,pbch_w_rx,dummy_w_rx,pbch_e_rx);
+
+  sub_block_deinterleaving_cc((unsigned int)(PBCH_A+16),
+                              &pbch_d_rx[96],
+                              &pbch_w_rx[0]);
+
+  memset(pbch_a,0,((16+PBCH_A)>>3));
+
+
+
+
   phy_viterbi_lte_sse2(pbch_d_rx+96,pbch_a,16+PBCH_A);
 
   // Fix byte endian of PBCH (bit 23 goes in first)

openair1/PHY/LTE_TRANSPORT/proto.h

@@ -1451,6 +1451,15 @@ uint16_t rx_pbch(LTE_UE_COMMON *lte_ue_common_vars,
                  uint32_t high_speed_flag,
                  uint8_t frame_mod4);
 
+uint16_t rx_pbch_freq(LTE_UE_COMMON *lte_ue_common_vars,
+                 LTE_UE_PBCH *lte_ue_pbch_vars,
+                 LTE_DL_FRAME_PARMS *frame_parms,
+                 uint8_t eNB_id,
+                 MIMO_mode_t mimo_mode,
+                 uint32_t high_speed_flag,
+                 uint8_t frame_mod4,
+		 uint16_t subframe);
+
 uint16_t rx_pbch_emul(PHY_VARS_UE *phy_vars_ue,
                       uint8_t eNB_id,
                       uint8_t pbch_phase);

openair1/PHY/MODULATION/slot_fep.c

@@ -439,7 +439,7 @@ int slot_fep_freq(PHY_VARS_UE *ue,
           start_meas(&ue->dlsch_freq_offset_estimation_stats);
 #endif
 
-        lte_est_freq_offset(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[Ns>>1]].dl_ch_estimates[0],
+        lte_est_freq_offset(common_vars->common_vars_rx_data_per_thread[(Ns>>1)&0x1].dl_ch_estimates[0],
                             frame_parms,
                             l,
                             &common_vars->freq_offset,
@@ -454,7 +454,7 @@ int slot_fep_freq(PHY_VARS_UE *ue,
   }
 
 #ifdef DEBUG_FEP
-  printf("slot_fep: done\n");
+  printf("slot_fep_freq: done\n");
 #endif
   return(0);
 }

openair1/PHY/impl_defs_top.h

@@ -184,7 +184,7 @@
 #define TARGET_RX_POWER_MAX 55    // Maximum digital power, such that signal does not saturate (value found by simulation)
 #define TARGET_RX_POWER_MIN 50    // Minimum digital power, anything below will be discarded (value found by simulation)
 #else
-#define TARGET_RX_POWER 50    // Target digital power for the AGC
+#define TARGET_RX_POWER 60    // Target digital power for the AGC
 #define TARGET_RX_POWER_MAX 65    // Maximum digital power, such that signal does not saturate (value found by simulation)
 #define TARGET_RX_POWER_MIN 35    // Minimum digital power, anything below will be discarded (value found by simulation)
 #endif

openair1/SCHED/phy_procedures_lte_ue.c

@@ -2711,6 +2711,7 @@ void ue_measurement_procedures(
 #ifndef OAI_BLADERF
 #ifndef OAI_LMSSDR
     phy_adjust_gain (ue,dB_fixed(ue->measurements.rssi),0);
+    printf("phy_adjust_gain phy_proc_ue\n");
 #endif
 #endif
 #endif
@@ -2891,7 +2892,7 @@ void restart_phy(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc, uint8_t eNB_id,uint8_t ab
 
 void ue_pbch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc, uint8_t abstraction_flag)
 {
-
+  //printf("PBCH: id %d\n",ue->Mod_id);
   //  int i;
   int pbch_tx_ant=0;
   uint8_t pbch_phase;
@@ -2995,7 +2996,7 @@ void ue_pbch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc, uin
         ue->proc.proc_rxtx[th_id].frame_rx = proc->frame_rx;
         ue->proc.proc_rxtx[th_id].frame_tx = proc->frame_tx;
 
-        printf("[UE %d] frame %d, subframe %d: Adjusting frame counter (PBCH ant_tx=%d, frame_tx=%d, phase %d, rx_offset %d) => new frame %d\n",
+        printf("[UE %d] frame %d, subframe %d: Adjusting frame counter (PBCH ant_tx=%d, frame_tx=%d, phase %d, rx_offset %d) => new frame %d (th_id %d)\n",
  	    ue->Mod_id,
  	    ue->proc.proc_rxtx[th_id].frame_rx,
  	    subframe_rx,
@@ -3003,7 +3004,8 @@ void ue_pbch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc, uin
  	    frame_tx,
  	    pbch_phase,
  	    ue->rx_offset,
- 	    proc->frame_rx);
+ 	    proc->frame_rx,
+	    th_id);
       }
 
 
@@ -3910,6 +3912,8 @@ void ue_dlsch_procedures(PHY_VARS_UE *ue,
   uint8_t is_cw0_active = 0;
   uint8_t is_cw1_active = 0;
 
+  printf("ue_dlsch_procedures id %d\n",ue->Mod_id);
+
   if (dlsch0==NULL)
       AssertFatal(0,"dlsch0 should be defined at this level \n");
 
@@ -4170,6 +4174,7 @@ void ue_dlsch_procedures(PHY_VARS_UE *ue,
          eNB_id);
     break;
   case SI_PDSCH:
+    //printf("SI_PDSCH id %d\n",ue->Mod_id);
     mac_xface->ue_decode_si(ue->Mod_id,
           CC_id,
           frame_rx,
@@ -5106,7 +5111,7 @@ int phy_procedures_UE_RX(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,
   } 
   count++;
   clock_t start=clock();*/
-
+  //printf("phy_procedures_UE_RX id %d\n",ue->Mod_id);
 
   int l,l2;
   int pilot1;

openair2/LAYER2/MAC/ue_procedures.c

@@ -461,6 +461,7 @@ ue_send_sdu(
                        ENB_FLAG_NO,
                        eNB_index,
                        0);
+	printf("1\n");
 
     } else if ((rx_lcids[i] == DCCH) || (rx_lcids[i] == DCCH1)) {
       LOG_D(MAC,"[UE %d] Frame %d : DLSCH -> DL-DCCH%d, RRC message (eNB %d, %d bytes)\n", module_idP, frameP, rx_lcids[i],eNB_index,rx_lengths[i]);
@@ -529,6 +530,7 @@ void ue_decode_si(module_id_t module_idP,int CC_id,frame_t frameP, uint8_t eNB_i
                    ENB_FLAG_NO,
                    eNB_index,
                    0);
+printf("2\n");
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_SI, VCD_FUNCTION_OUT);
 #if UE_TIMING_TRACE
   stop_meas(&UE_mac_inst[module_idP].rx_si);
@@ -568,6 +570,7 @@ void ue_decode_p(module_id_t module_idP,int CC_id,frame_t frameP, uint8_t eNB_in
                    ENB_FLAG_NO,
                    eNB_index,
                    0);
+printf("3\n");
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_PCCH, VCD_FUNCTION_OUT);
 #if UE_TIMING_TRACE
   stop_meas(&UE_mac_inst[module_idP].rx_p);
@@ -674,6 +677,7 @@ void ue_send_mch_sdu(module_id_t module_idP, uint8_t CC_id, frame_t frameP, uint
                        M_RNTI,
                        MCCH,
                        payload_ptr, rx_lengths[i], 0, eNB_index, sync_area);
+printf("4\n");
     } else if (rx_lcids[i] == MTCH) {
       if (UE_mac_inst[module_idP].msi_status==1) {
         LOG_I(MAC,"[UE %d] Frame %d : MCH->MTCH for sync area %d (eNB %d, %d bytes)\n",module_idP,frameP, sync_area, eNB_index, rx_lengths[i]);

openair2/RRC/LITE/rrc_UE.c

@@ -2704,8 +2704,8 @@ int decode_BCCH_DLSCH_Message(
   }
 # endif
 #endif
-
   if (bcch_message->message.present == BCCH_DL_SCH_MessageType_PR_c1) {
+    printf("Before SIB1: bcch_message->message.choice.c1.present %d, BCCH_DL_SCH_MessageType__c1_PR_systemInformationBlockType1 %d, BCCH_DL_SCH_MessageType__c1_PR_systemInformation %d, id %d, frame %d, CASE %s\n",bcch_message->message.choice.c1.present,BCCH_DL_SCH_MessageType__c1_PR_systemInformationBlockType1,BCCH_DL_SCH_MessageType__c1_PR_systemInformation,ctxt_pP->module_id,ctxt_pP->frame, ((ctxt_pP->frame % 2) == 0&&((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&1) == 0) )?"SIB1":((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&1) == 1)?"SIB2":"Other case");
     switch (bcch_message->message.choice.c1.present) {
     case BCCH_DL_SCH_MessageType__c1_PR_systemInformationBlockType1:
       if ((ctxt_pP->frame % 2) == 0) {
@@ -2716,6 +2716,7 @@ int decode_BCCH_DLSCH_Message(
                   (void*)&bcch_message->message.choice.c1.choice.systemInformationBlockType1,
                   sizeof(SystemInformationBlockType1_t) );
           LOG_D( RRC, "[UE %"PRIu8"] Decoding First SIB1\n", ctxt_pP->module_id );
+	  printf("SIB1: BCCH_DL_SCH_MessageType__c1_PR_systemInformationBlockType1 %d, ctxt_pP->frame % 2 == 0? %d, UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&1 == 0? %d, frame %d\n",BCCH_DL_SCH_MessageType__c1_PR_systemInformationBlockType1,((ctxt_pP->frame % 2) == 0),((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&1) == 0),ctxt_pP->frame);
           decode_SIB1( ctxt_pP, eNB_index, rsrq, rsrp );
           //printf("decode_BCCH_DLSCH_Message \n");
         }
@@ -2735,7 +2736,7 @@ int decode_BCCH_DLSCH_Message(
         LOG_I( RRC, "[UE %"PRIu8"] Decoding SI for frameP %"PRIu32"\n",
                ctxt_pP->module_id,
                ctxt_pP->frame );
-
+	printf("Decoding SI: BCCH_DL_SCH_MessageType__c1_PR_systemInformation %d, (UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&1) %d\n",BCCH_DL_SCH_MessageType__c1_PR_systemInformation,(UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&1));
         decode_SI( ctxt_pP, eNB_index );
       }
       break;
@@ -4275,15 +4276,17 @@ void *rrc_ue_task( void *args_p )
 
   protocol_ctxt_t  ctxt;
   itti_mark_task_ready (TASK_RRC_UE);
-
+  /*printf("Cases:  TERMINATE_MESSAGE%d, MESSAGE_TEST %d, RRC_MAC_IN_SYNC_IND %d, RRC_MAC_OUT_OF_SYNC_IND %d, RRC_MAC_BCCH_DATA_IND %d, RRC_MAC_CCCH_DATA_CNF %d,RRC_MAC_CCCH_DATA_IND %d, RRC_MAC_MCCH_DATA_IND %d,RRC_DCCH_DATA_IND %d,NAS_KENB_REFRESH_REQ %d,NAS_CELL_SELECTION_REQ %d,RRC_STATE_INACTIVE %d,RRC_STATE_IDLE %d,RRC_STATE_CONNECTED %d,NAS_CONN_ESTABLI_REQ %d,PHY_FIND_CELL_IND %d\n\n",TERMINATE_MESSAGE,MESSAGE_TEST,RRC_MAC_IN_SYNC_IND,RRC_MAC_OUT_OF_SYNC_IND,RRC_MAC_BCCH_DATA_IND,RRC_MAC_CCCH_DATA_CNF,RRC_MAC_CCCH_DATA_IND,RRC_MAC_MCCH_DATA_IND,RRC_DCCH_DATA_IND,
+NAS_KENB_REFRESH_REQ,NAS_CELL_SELECTION_REQ,RRC_STATE_INACTIVE,RRC_STATE_IDLE,RRC_STATE_CONNECTED,NAS_CONN_ESTABLI_REQ,PHY_FIND_CELL_IND);*/
   while(1) {
+
     // Wait for a message
     itti_receive_msg (TASK_RRC_UE, &msg_p);
 
     msg_name = ITTI_MSG_NAME (msg_p);
     instance = ITTI_MSG_INSTANCE (msg_p);
     ue_mod_id = UE_INSTANCE_TO_MODULE_ID(instance);
-
+    printf("rrc_ue_task... wait for a message. Case %d, id %d\n",ITTI_MSG_ID(msg_p),ue_mod_id);
     switch (ITTI_MSG_ID(msg_p)) {
     case TERMINATE_MESSAGE:
       itti_exit_task ();

targets/RT/USER/lte-ue.c

@@ -754,7 +754,6 @@ static void *UE_thread_synch_freq(void *arg) {
 
         VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_THREAD_SYNCH, 0 );
     }  // while !oai_exit
-
     return &UE_thread_synch_retval;
 }
 

targets/SIMU/USER/channel_sim.c

@@ -707,8 +707,10 @@ void do_DL_sig_freq(channel_desc_t *eNB2UE[NUMBER_OF_eNB_MAX][NUMBER_OF_UE_MAX][
               //for (int idx=0;idx<10;idx++) printf("dumping DL raw subframe %d: rxdataF0[%d] = (%d,%d)\n", subframe, idx, ((short*)&rxdataF[0][sf_offset+idx])[0], ((short*)&rxdataF[0][sf_offset+idx])[1]);
       	        //print_meas (&eNB2UE[eNB_id][UE_id][CC_id]->DL_adc,"[DL][adc]", &eNB2UE[eNB_id][UE_id][CC_id]->DL_adc, &eNB2UE[eNB_id][UE_id][CC_id]->DL_adc);
              //for (int idx=0;idx<10;idx++) printf("dumping DL raw rx subframe %d: rxdataF[%d] = (%d,%d)=====>%s,txdataF[%d] = (%d,%d), r_re_im_p_f(%e,%e)\n", subframe, idx, ((short*)&rxdataF[0][sf_offset+idx])[0], ((short*)&rxdataF[0][sf_offset+idx])[1],(((((r_re_p_f[0][idx]<0)&&(((short*)&rxdataF[0][sf_offset+idx])[0]<0))||((r_re_p_f[0][idx]>=0)&&(((short*)&rxdataF[0][sf_offset+idx])[0]>=0))))&&(((r_im_p_f[0][idx]<0)&&(((short*)&rxdataF[0][sf_offset+idx])[1]<0))||((r_im_p_f[0][idx]>=0)&&(((short*)&rxdataF[0][sf_offset+idx])[1]>=0))))?"OK":"ERROR",idx,((short*)&txdataF[0][sf_offset+idx])[0],((short*)&txdataF[0][sf_offset+idx])[1],r_re_p_f[0][idx],r_im_p_f[0][idx]);
-
-		//write_output("chsim_rxsigF_subframe0.m","chsm_rxsF0", PHY_vars_UE_g[UE_id][CC_id]->common_vars.common_vars_rx_data_per_thread[0].rxdataF[0],10*frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti,1,16);
+	if (UE_id==0)
+		write_output("chsim0_rxsigF_subframe0.m","chsm0_rxsF0", PHY_vars_UE_g[UE_id][CC_id]->common_vars.common_vars_rx_data_per_thread[0].rxdataF[0],10*frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti,1,16);
+	else
+		write_output("chsim1_rxsigF_subframe0.m","chsm1_rxsF0", PHY_vars_UE_g[UE_id][CC_id]->common_vars.common_vars_rx_data_per_thread[0].rxdataF[0],10*frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti,1,16);
 		//write_output("chsim_rxsigF_subframe1.m","chsm_rxsF1", PHY_vars_UE_g[UE_id][CC_id]->common_vars.common_vars_rx_data_per_thread[1].rxdataF[0],10*frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti,1,16);
 	
 #ifdef DEBUG_SIM
@@ -1375,11 +1377,11 @@ void do_UL_sig_freq_prach(channel_desc_t *UE2eNB[NUMBER_OF_UE_MAX][NUMBER_OF_eNB
       if (((double)PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm[subframe] +
 	   UE2eNB[UE_id][eNB_id][CC_id]->path_loss_dB) <= -125.0) {
 	// don't simulate a UE that is too weak
-	LOG_D(OCM,"[SIM][UL] UE %d tx_pwr %d dBm (num_RE %d) for subframe %d (sf_offset %d)\n",
+	/*LOG_D(OCM,"[SIM][UL] PRACH:UE %d tx_pwr %d dBm (num_RE %d) for subframe %d (sf_offset %d)\n",
 	      UE_id,
 	      PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm[subframe],
 	      PHY_vars_UE_g[UE_id][CC_id]->tx_total_RE[subframe],
-	      subframe,sf_offset);
+	      subframe,sf_offset);*/
 	      //printf("multipath_channel_prach, UE too weak %e\n", ((double)PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm[subframe] +
 	   //UE2eNB[UE_id][eNB_id][CC_id]->path_loss_dB));	
       } else {
@@ -1414,12 +1416,12 @@ void do_UL_sig_freq_prach(channel_desc_t *UE2eNB[NUMBER_OF_UE_MAX][NUMBER_OF_eNB
 	    stop_meas(&UE2eNB[0][eNB_id][CC_id]->dac_fixed_gain_PRACH);
 	    //for (int idx=0;idx<10;idx++) printf("dumping raw PRACH UL tx subframe (input) %d: s_f[%d] = (%f,%f)\n", subframe, idx, s_re_f_prach[0][idx],s_im_f_prach[0][idx]);
 	    //for (int idx=829;idx<839;idx++) printf("dumping raw PRACH UL tx subframe (input) %d: s_f[%d] = (%f,%f)\n", subframe, idx, s_re_f_prach[0][idx],s_im_f_prach[0][idx]);
-	    LOG_D(OCM,"[SIM][UL] UE %d tx_pwr %f dBm (target %d dBm, num_RE %d) for subframe %d (sf_offset %d)\n",
+	    /*LOG_D(OCM,"[SIM][UL] UE %d tx_pwr %f dBm (target %d dBm, num_RE %d) for subframe %d (sf_offset %d)\n",
 		      UE_id,
 		      10*log10(tx_pwr),
 		      PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm[subframe],
 		      PHY_vars_UE_g[UE_id][CC_id]->tx_total_RE[subframe],
-		      subframe,sf_offset);
+		      subframe,sf_offset);*/
 
 	    
 
@@ -1438,20 +1440,20 @@ void do_UL_sig_freq_prach(channel_desc_t *UE2eNB[NUMBER_OF_UE_MAX][NUMBER_OF_eNB
 	    //for (int idx=829;idx<839;idx++) printf("dumping raw PRACH UL tx subframe (output) %d: r_f[%d] = (%f,%f)\n", subframe, idx, r_re0_f_prach[0][idx],r_im0_f_prach[0][idx]);
 		//write_output("txprachF.m","prach_txF", PHY_vars_UE_g[0][0]->prach_vars[0]->prachF,frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti,1,1);
 	     rx_pwr = signal_energy_fp2(UE2eNB[UE_id][eNB_id][CC_id]->chF[0],(12*frame_parms->N_RB_DL+1))*(12*frame_parms->N_RB_DL+1);
-	     LOG_D(OCM,"[SIM][UL] subframe %d Channel UE %d => eNB %d : %f dB (hold %d,length %d, PL %f)\n",subframe,UE_id,eNB_id,10*log10(rx_pwr),
+	     /*LOG_D(OCM,"[SIM][UL] subframe %d Channel UE %d => eNB %d : %f dB (hold %d,length %d, PL %f)\n",subframe,UE_id,eNB_id,10*log10(rx_pwr),
 	     hold_channel,12*frame_parms->N_RB_DL+1,
-	     UE2eNB[UE_id][eNB_id][CC_id]->path_loss_dB);
+	     UE2eNB[UE_id][eNB_id][CC_id]->path_loss_dB);*/
 #ifdef    SSE_float 
 	     rx_pwr = signal_energy_fp_SSE_float(r_re0_f_prach,r_im0_f_prach,nb_antennas_rx,frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti*12,0);
 #else
 	     rx_pwr = signal_energy_fp(r_re0_f_prach,r_im0_f_prach,nb_antennas_rx,frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti*12,0);
 #endif
-	     LOG_D(OCM,"[SIM][UL] eNB %d : rx_pwr %f dBm (%f) for subframe %d, sptti %d\n",
-	      eNB_id,10*log10(rx_pwr),rx_pwr,subframe,frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti*12);
+	     /*LOG_D(OCM,"[SIM][UL] eNB %d : rx_pwr %f dBm (%f) for subframe %d, sptti %d\n",
+	      eNB_id,10*log10(rx_pwr),rx_pwr,subframe,frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti*12);*/
 #ifdef DEBUG_SIM
 
-      	for (i=0; i<10; i++)
-        LOG_D(OCM,"do_UL_prach channel(%d,%d)[%d] : (%f,%f)\n",UE_id,eNB_id,i,UE2eNB[UE_id][eNB_id][CC_id]->chF_prach[0][i].x,UE2eNB[UE_id][eNB_id][CC_id]->chF_prach[0][i].y);
+      	/*for (i=0; i<10; i++)
+        LOG_D(OCM,"do_UL_prach channel(%d,%d)[%d] : (%f,%f)\n",UE_id,eNB_id,i,UE2eNB[UE_id][eNB_id][CC_id]->chF_prach[0][i].x,UE2eNB[UE_id][eNB_id][CC_id]->chF_prach[0][i].y);*/
 
 #endif	
 	     /*for (i=0; i<864; i++){
@@ -1511,7 +1513,7 @@ void do_UL_sig_freq_prach(channel_desc_t *UE2eNB[NUMBER_OF_UE_MAX][NUMBER_OF_eNB
 #ifdef DEBUG_SIM
 
     rx_pwr = signal_energy_fp(r_re_p_f_prach,r_im_p_f_prach,nb_antennas_rx,frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti*12,0)*(double)frame_parms->ofdm_symbol_size/(12.0*frame_parms->N_RB_DL);
-    LOG_D(OCM,"[SIM][UL] rx_pwr (ADC in) %f dB for subframe %d\n",10*log10(rx_pwr),subframe);
+    /*LOG_D(OCM,"[SIM][UL] rx_pwr (ADC in) %f dB for subframe %d\n",10*log10(rx_pwr),subframe);*/
 
 #endif
      rx_prachF = PHY_vars_eNB_g[eNB_id][CC_id]->prach_vars.rxsigF;

targets/SIMU/USER/oaisim.c

@@ -769,7 +769,7 @@ l2l1_task (void *args_p)
                  + oai_emulation.info.nb_enb_local));
              eNB_inst++) {
           for (CC_id = 0; CC_id < MAX_NUM_CCs; CC_id++){
-	     if (PHY_vars_UE_g[0][0]->do_ofdm_mod)//frequency analysis
+	     if (PHY_vars_UE_g[0][CC_id]->do_ofdm_mod)//frequency analysis
             	current_eNB_rx_timestamp[eNB_inst][CC_id] += PHY_vars_eNB_g[eNB_inst][CC_id]->frame_parms.ofdm_symbol_size*PHY_vars_eNB_g[eNB_inst][CC_id]->frame_parms.symbols_per_tti;
 	     else//time analysis
                 current_eNB_rx_timestamp[eNB_inst][CC_id] += PHY_vars_eNB_g[eNB_inst][CC_id]->frame_parms.samples_per_tti;
@@ -777,7 +777,7 @@ l2l1_task (void *args_p)
         }
         for (UE_inst = 0; UE_inst<NB_UE_INST;UE_inst++) {
           for (CC_id = 0; CC_id < MAX_NUM_CCs; CC_id++){
-            if (PHY_vars_UE_g[0][0]->do_ofdm_mod)//frequency analysis
+            if (PHY_vars_UE_g[UE_inst][CC_id]->do_ofdm_mod)//frequency analysis
             	current_UE_rx_timestamp[UE_inst][CC_id] += PHY_vars_UE_g[UE_inst][CC_id]->frame_parms.ofdm_symbol_size*PHY_vars_UE_g[UE_inst][CC_id]->frame_parms.symbols_per_tti;
 	    else//time analysis
 		current_UE_rx_timestamp[UE_inst][CC_id] += PHY_vars_UE_g[UE_inst][CC_id]->frame_parms.samples_per_tti;	

targets/SIMU/USER/oaisim_functions.c

@@ -1043,7 +1043,7 @@ extern int subframe_eNB_mask,subframe_UE_mask;
 
 int eNB_trx_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int cc)
 {
-  static int first_run=0;
+  /*static int first_run=0;
   static double sum;
   static int count1;
   if (!first_run)
@@ -1060,7 +1060,7 @@ int eNB_trx_read(openair0_device *device, openair0_timestamp *ptimestamp, void *
      print_opp_meas_oaisim ();
      reset_opp_meas_oaisim ();
   }
-  count++;
+  count++;*/
 
   int ret = nsamps;
   int eNB_id = device->Mod_id;
@@ -1126,11 +1126,12 @@ int eNB_trx_read(openair0_device *device, openair0_timestamp *ptimestamp, void *
       //printf("is Prach generated? %d, is prach_subframe? %d, frame %d, subframe %d, mode %d\n",PHY_vars_UE_g[0][CC_id]->generate_prach,is_prach_subframe(frame_parms,frame,subframe),frame,subframe,PHY_vars_UE_g[0][CC_id]->UE_mode[eNB_id]);
       if (do_ofdm_mod)
       {
-	for (UE_id=NB_UE_INST-1; UE_id>=0; UE_id--){
+	for (UE_id=0; UE_id<NB_UE_INST; UE_id++){
 		if (is_prach_subframe(&PHY_vars_UE_g[UE_id][CC_id]->frame_parms,frame,subframe) && PHY_vars_UE_g[UE_id][CC_id]->generate_prach)
 		{
 			start_meas(&UE2eNB[UE_id][eNB_id][CC_id]->UL_PRACH_channel);
-			clock_t start=clock();
+			//clock_t start=clock();
+			printf("subframe UL PRACH: %d\n",subframe);
 			do_UL_sig_freq_prach(UE2eNB,
 				enb_data,
 				ue_data,
@@ -1140,10 +1141,10 @@ int eNB_trx_read(openair0_device *device, openair0_timestamp *ptimestamp, void *
 				0,  // frame is only used for abstraction
 				eNB_id,
 				CC_id);
-  			clock_t stop=clock();
-  			printf("do_DL_sig time_prach is %f s, AVERAGE time is %f s, count %d, sum %e\n",(float) (stop-start)/CLOCKS_PER_SEC,(float) (sum+stop-start)/(count1*CLOCKS_PER_SEC),count1,sum+stop-start);
+  			//clock_t stop=clock();
+  			/*printf("do_DL_sig time_prach is %f s, AVERAGE time is %f s, count %d, sum %e\n",(float) (stop-start)/CLOCKS_PER_SEC,(float) (sum+stop-start)/(count1*CLOCKS_PER_SEC),count1,sum+stop-start);
   			sum=(sum+stop-start);
-        		count1++;
+        		count1++;*/
 		        stop_meas(&UE2eNB[UE_id][eNB_id][CC_id]->UL_PRACH_channel);
 			//write_output("txprachF.m","prach_txF", PHY_vars_UE_g[0][CC_id]->prach_vars[0]->prachF,12*frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti,1,16);
 			break;
@@ -1546,7 +1547,7 @@ void init_openair1(void)
     for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
 
       PHY_vars_UE_g[UE_id][CC_id]->tx_power_max_dBm=10;
-
+      
       PHY_vars_UE_g[UE_id][CC_id]->rx_total_gain_dB=100;
 
       // update UE_mode for each eNB_id not just 0