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_ESTIMATION/lte_ue_measurements.c

@@ -194,6 +194,10 @@ void ue_rrc_measurements(PHY_VARS_UE *ue,
   //int16_t *re,*im; // real and imag part of each 32-bit xss_ext[][] value
 
   //LOG_I(PHY,"UE RRC MEAS Start Subframe %d Frame Type %d slot %d \n",subframe,ue->frame_parms.frame_type,slot);
+  //printf("ue->measurements.n_adj_cells %d\n",ue->measurements.n_adj_cells);
+  //printf("before ue->measurements.rssi %d\n",ue->measurements.rssi);
+  //printf("ue->current_thread_id[%d] %d\n",subframe,ue->current_thread_id[subframe]);
+  //printf("previous_thread_id %d\n",previous_thread_id);
   for (eNB_offset = 0; eNB_offset<1+ue->measurements.n_adj_cells; eNB_offset++) {
 
     if (eNB_offset==0) {
@@ -345,8 +349,8 @@ void ue_rrc_measurements(PHY_VARS_UE *ue,
       for (l=0,nu=0; l<=(4-ue->frame_parms.Ncp); l+=(4-ue->frame_parms.Ncp),nu=3) {
         k = (nu + nushift)%6;
 #ifdef DEBUG_MEAS_RRC
-        LOG_I(PHY,"[UE %d] Frame %d subframe %d Doing ue_rrc_measurements rsrp/rssi (Nid_cell %d, nushift %d, eNB_offset %d, k %d, l %d)\n",ue->Mod_id,ue->proc.proc_rxtx[subframe&1].frame_rx,subframe,Nid_cell,nushift,
-              eNB_offset,k,l);
+        LOG_I(PHY,"[UE %d] Frame %d subframe %d Doing ue_rrc_measurements rsrp/rssi (Nid_cell %d, nushift %d, eNB_offset %d, k %d, l %d, nu %d, subframe %d)\n",ue->Mod_id,ue->proc.proc_rxtx[subframe&1].frame_rx,subframe,Nid_cell,nushift,
+              eNB_offset,k,l,nu,subframe);
 #endif
 
         for (aarx=0; aarx<ue->frame_parms.nb_antennas_rx; aarx++) {
@@ -363,7 +367,7 @@ void ue_rrc_measurements(PHY_VARS_UE *ue,
               //              if ((ue->frame_rx&0x3ff) == 0)
               //                printf("rb %d, off %d : %d\n",rb,off,((rxF[off]*rxF[off])+(rxF[off+1]*rxF[off+1])));
 
-
+	      //printf("rxF[%d+%d=%d] %d\n",off,(l*ue->frame_parms.ofdm_symbol_size),off+(l*ue->frame_parms.ofdm_symbol_size),rxF[off]);
               off+=12;
 
               if (off>=(ue->frame_parms.ofdm_symbol_size<<1))
@@ -406,13 +410,14 @@ void ue_rrc_measurements(PHY_VARS_UE *ue,
         //  ue->measurements.rssi*=rx_power_correction;
         //  ue->measurements.rssi=ue->measurements.rsrp[0]*24/2;
         ue->measurements.rssi=ue->measurements.rsrp[0]*(12*ue->frame_parms.N_RB_DL);
+	printf("ue->measurements.rsrp[0] %d\n",ue->measurements.rsrp[0]);
       }
 
       if (ue->measurements.rssi>0)
         ue->measurements.rsrq[eNB_offset] = 100*ue->measurements.rsrp[eNB_offset]*ue->frame_parms.N_RB_DL/ue->measurements.rssi;
       else
         ue->measurements.rsrq[eNB_offset] = -12000;
-
+      printf("after ue->measurements.rssi %d\n",ue->measurements.rssi);
       //((200*ue->measurements.rsrq[eNB_offset]) + ((1024-200)*100*ue->measurements.rsrp[eNB_offset]*ue->frame_parms.N_RB_DL/ue->measurements.rssi))>>10;
     } else { // Do abstraction of RSRP and RSRQ
       ue->measurements.rssi = ue->measurements.rx_power_avg[0];
@@ -478,6 +483,10 @@ void ue_rrc_measurements_freq(PHY_VARS_UE *ue,
   //int16_t *re,*im; // real and imag part of each 32-bit xss_ext[][] value
 
   //LOG_I(PHY,"UE RRC MEAS Start Subframe %d Frame Type %d slot %d \n",subframe,ue->frame_parms.frame_type,slot);
+  //printf("ue->measurements.n_adj_cells %d\n",ue->measurements.n_adj_cells);
+  //printf("before ue->measurements.rssi %d\n",ue->measurements.rssi);
+  //printf("ue->current_thread_id[%d] %d\n",subframe,ue->current_thread_id[subframe]);
+  //printf("previous_thread_id %d\n",previous_thread_id);
   for (eNB_offset = 0; eNB_offset<1+ue->measurements.n_adj_cells; eNB_offset++) {
 
     if (eNB_offset==0) {
@@ -495,13 +504,13 @@ void ue_rrc_measurements_freq(PHY_VARS_UE *ue,
 
           if(ue->frame_parms.frame_type == FDD)
           {
-	      rxF_sss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF[aarx][(5*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
-	      rxF_pss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF[aarx][(6*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
+	      rxF_sss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[aarx][(5*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
+	      rxF_pss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[aarx][(6*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
           }
           else
           {
-              rxF_sss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[previous_thread_id].rxdataF[aarx][(13*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
-              rxF_pss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF[aarx][(2*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
+              rxF_sss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[(subframe&0x1==1)?0:1].rxdataF[aarx][(13*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
+              rxF_pss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[aarx][(2*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
           }
               //-ve spectrum from SSS
 
@@ -519,13 +528,13 @@ void ue_rrc_measurements_freq(PHY_VARS_UE *ue,
           //          printf("pss32 %d\n",ue->measurements.n0_power[aarx]);              //-ve spectrum from PSS
               if(ue->frame_parms.frame_type == FDD)
               {
-                  rxF_sss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF[aarx][(6*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
-                  rxF_pss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF[aarx][(7*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
+                  rxF_sss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[aarx][(6*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
+                  rxF_pss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[aarx][(7*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
               }
               else
               {
-                  rxF_sss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[previous_thread_id].rxdataF[aarx][(14*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
-                  rxF_pss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF[aarx][(3*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
+                  rxF_sss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[(subframe&0x1==1)?0:1].rxdataF[aarx][(14*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
+                  rxF_pss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[aarx][(3*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
               }
           //              ue->measurements.n0_power[aarx] += (((int32_t)rxF_pss[-72]*rxF_pss[-72])+((int32_t)rxF_pss[-71]*rxF_pss[-71]));
           //          printf("pssm36 %d\n",ue->measurements.n0_power[aarx]);
@@ -560,10 +569,10 @@ void ue_rrc_measurements_freq(PHY_VARS_UE *ue,
           if (ue->frame_parms.Ncp==NORMAL) {
             for (aarx=0; aarx<ue->frame_parms.nb_antennas_rx; aarx++) {
 
-                rxdataF  =  ue->common_vars.common_vars_rx_data_per_thread[(ue->current_thread_id[subframe])].rxdataF;
+                rxdataF  =  ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF;
                 rxF_pss  = (int16_t *) &rxdataF[aarx][((pss_symb*(ue->frame_parms.ofdm_symbol_size)))+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
 
-                rxdataF  =  ue->common_vars.common_vars_rx_data_per_thread[previous_thread_id].rxdataF;
+                rxdataF  =  ue->common_vars.common_vars_rx_data_per_thread[(subframe&0x1==1)?0:1].rxdataF;
                 rxF_sss  = (int16_t *) &rxdataF[aarx][((sss_symb*(ue->frame_parms.ofdm_symbol_size)))+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
 
                 //-ve spectrum from SSS
@@ -588,7 +597,7 @@ void ue_rrc_measurements_freq(PHY_VARS_UE *ue,
                 ue->measurements.n0_power[aarx] += (((int32_t)rxF_pss[2+66]*rxF_pss[2+66])+((int32_t)rxF_pss[2+65]*rxF_pss[2+65]));
             //              ue->measurements.n0_power[aarx] += (((int32_t)rxF_pss[2+64]*rxF_pss[2+64])+((int32_t)rxF_pss[2+63]*rxF_pss[2+63]));
             //          printf("pss32 %d\n",ue->measurements.n0_power[aarx]);              //-ve spectrum from PSS
-                rxF_pss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF[aarx][(7*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
+                rxF_pss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[aarx][(7*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
             //              ue->measurements.n0_power[aarx] += (((int32_t)rxF_pss[-72]*rxF_pss[-72])+((int32_t)rxF_pss[-71]*rxF_pss[-71]));
             //          printf("pssm36 %d\n",ue->measurements.n0_power[aarx]);
                 ue->measurements.n0_power[aarx] += (((int32_t)rxF_pss[-70]*rxF_pss[-70])+((int32_t)rxF_pss[-69]*rxF_pss[-69]));
@@ -629,20 +638,21 @@ void ue_rrc_measurements_freq(PHY_VARS_UE *ue,
       for (l=0,nu=0; l<=(4-ue->frame_parms.Ncp); l+=(4-ue->frame_parms.Ncp),nu=3) {
         k = (nu + nushift)%6;
 #ifdef DEBUG_MEAS_RRC
-        LOG_I(PHY,"[UE %d] Frame %d subframe %d Doing ue_rrc_measurements rsrp/rssi (Nid_cell %d, nushift %d, eNB_offset %d, k %d, l %d)\n",ue->Mod_id,ue->proc.proc_rxtx[subframe&1].frame_rx,subframe,Nid_cell,nushift,
-              eNB_offset,k,l);
+        LOG_I(PHY,"[UE %d] Frame %d subframe %d Doing ue_rrc_measurements rsrp/rssi (Nid_cell %d, nushift %d, eNB_offset %d, k %d, l %d, nu %d, subframe %d)\n",ue->Mod_id,ue->proc.proc_rxtx[subframe&1].frame_rx,subframe,Nid_cell,nushift,
+              eNB_offset,k,l,nu,subframe);
 #endif
 
         for (aarx=0; aarx<ue->frame_parms.nb_antennas_rx; aarx++) {
-          rxF = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF[aarx][(l*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
+          rxF = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[aarx][(l*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)];
           off  = (ue->frame_parms.first_carrier_offset+k)<<1;
-
+	  //printf("first_carrier_offset %d, off %d, subframe %d\n",ue->frame_parms.first_carrier_offset,off,subframe);
           if (l==(4-ue->frame_parms.Ncp)) {
             for (rb=0; rb<ue->frame_parms.N_RB_DL; rb++) {
 
               //    printf("rb %d, off %d, off2 %d\n",rb,off,off2);
 
               ue->measurements.rsrp[eNB_offset] += (((int32_t)(rxF[off])*rxF[off])+((int32_t)(rxF[off+1])*rxF[off+1]));
+	      //printf("rxF[%d+%d=%d] %d\n",off,(l*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti),(l*ue->frame_parms.ofdm_symbol_size)+subframe*(ue->frame_parms.ofdm_symbol_size*ue->frame_parms.symbols_per_tti)+off,rxF[off]);
               //        printf("rb %d, off %d : %d\n",rb,off,((((int32_t)rxF[off])*rxF[off])+((int32_t)(rxF[off+1])*rxF[off+1])));
               //              if ((ue->frame_rx&0x3ff) == 0)
               //                printf("rb %d, off %d : %d\n",rb,off,((rxF[off]*rxF[off])+(rxF[off+1]*rxF[off+1])));
@@ -690,13 +700,14 @@ void ue_rrc_measurements_freq(PHY_VARS_UE *ue,
         //  ue->measurements.rssi*=rx_power_correction;
         //  ue->measurements.rssi=ue->measurements.rsrp[0]*24/2;
         ue->measurements.rssi=ue->measurements.rsrp[0]*(12*ue->frame_parms.N_RB_DL);
+	printf("ue->measurements.rsrp[0] %d\n",ue->measurements.rsrp[0]);
       }
 
       if (ue->measurements.rssi>0)
         ue->measurements.rsrq[eNB_offset] = 100*ue->measurements.rsrp[eNB_offset]*ue->frame_parms.N_RB_DL/ue->measurements.rssi;
       else
         ue->measurements.rsrq[eNB_offset] = -12000;
-
+      printf("after ue->measurements.rssi %d\n",ue->measurements.rssi);
       //((200*ue->measurements.rsrq[eNB_offset]) + ((1024-200)*100*ue->measurements.rsrp[eNB_offset]*ue->frame_parms.N_RB_DL/ue->measurements.rssi))>>10;
     } else { // Do abstraction of RSRP and RSRQ
       ue->measurements.rssi = ue->measurements.rx_power_avg[0];
@@ -868,7 +879,7 @@ void lte_ue_measurements(PHY_VARS_UE *ue,
     ue->measurements.n0_power_avg = ue->measurements.n0_power_tot;
     ue->init_averaging = 0;
   }
-
+  //printf("[UE %d] UE %d connected to eNB %d\n",ue->Mod_id,ue->n_connected_eNB,eNB_id);
   for (eNB_id = 0; eNB_id < ue->n_connected_eNB; eNB_id++) {
     ue->measurements.rx_power_avg_dB[eNB_id] = dB_fixed( ue->measurements.rx_power_avg[eNB_id]);
     ue->measurements.wideband_cqi_tot[eNB_id] = dB_fixed2(ue->measurements.rx_power_tot[eNB_id],ue->measurements.n0_power_tot);
@@ -1108,7 +1119,377 @@ void lte_ue_measurements(PHY_VARS_UE *ue,
   _m_empty();
 #endif
 }
+void lte_ue_measurements_freq(PHY_VARS_UE *ue,
+                         unsigned int subframe_offset,
+                         unsigned char N0_symbol,
+                         unsigned char abstraction_flag,
+                         unsigned char rank_adaptation,
+                         uint8_t subframe)
+{
+
+
+  int aarx,aatx,eNB_id=0; //,gain_offset=0;
+  //int rx_power[NUMBER_OF_CONNECTED_eNB_MAX];
+  int i;
+  unsigned int limit,subband;
+#if defined(__x86_64__) || defined(__i386__)
+  __m128i *dl_ch0_128,*dl_ch1_128;
+#elif defined(__arm__)
+  int16x8_t *dl_ch0_128, *dl_ch1_128;
+#endif
+  int *dl_ch0,*dl_ch1;
+
+  LTE_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
+  int nb_subbands,subband_size,last_subband_size;
+  int N_RB_DL = frame_parms->N_RB_DL;
+
+
+  int rank_tm3_tm4;
+
+
+  ue->measurements.nb_antennas_rx = frame_parms->nb_antennas_rx;
+
+
+  switch (N_RB_DL) {
+  case 6:
+    nb_subbands = 6;
+    subband_size = 12;
+    last_subband_size = 0;
+    break;
+
+  default:
+  case 25:
+    nb_subbands = 7;
+    subband_size = 4*12;
+    last_subband_size = 12;
+    break;
+
+  case 50:
+    nb_subbands = 9;
+    subband_size = 6*12;
+    last_subband_size = 2*12;
+    break;
+
+  case 100:
+    nb_subbands = 13;
+    subband_size = 8*12;
+    last_subband_size = 4*12;
+    break;
+  }
+
+  // signal measurements
+  for (eNB_id=0; eNB_id<ue->n_connected_eNB; eNB_id++) {
+    for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+      for (aatx=0; aatx<frame_parms->nb_antenna_ports_eNB; aatx++) {
+        ue->measurements.rx_spatial_power[eNB_id][aatx][aarx] =
+          (signal_energy_nodc(&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][(aatx<<1) + aarx][0],
+                              (N_RB_DL*12)));
+        //- ue->measurements.n0_power[aarx];
+
+        if (ue->measurements.rx_spatial_power[eNB_id][aatx][aarx]<0)
+          ue->measurements.rx_spatial_power[eNB_id][aatx][aarx] = 0; //ue->measurements.n0_power[aarx];
+
+        ue->measurements.rx_spatial_power_dB[eNB_id][aatx][aarx] = (unsigned short) dB_fixed(ue->measurements.rx_spatial_power[eNB_id][aatx][aarx]);
+
+        if (aatx==0)
+          ue->measurements.rx_power[eNB_id][aarx] = ue->measurements.rx_spatial_power[eNB_id][aatx][aarx];
+        else
+          ue->measurements.rx_power[eNB_id][aarx] += ue->measurements.rx_spatial_power[eNB_id][aatx][aarx];
+      } //aatx
+
+      ue->measurements.rx_power_dB[eNB_id][aarx] = (unsigned short) dB_fixed(ue->measurements.rx_power[eNB_id][aarx]);
+
+      if (aarx==0)
+        ue->measurements.rx_power_tot[eNB_id] = ue->measurements.rx_power[eNB_id][aarx];
+      else
+        ue->measurements.rx_power_tot[eNB_id] += ue->measurements.rx_power[eNB_id][aarx];
+    } //aarx
+
+    ue->measurements.rx_power_tot_dB[eNB_id] = (unsigned short) dB_fixed(ue->measurements.rx_power_tot[eNB_id]);
 
+  } //eNB_id
+
+  eNB_id=0;
+  if (ue->transmission_mode[0]==4 || ue->transmission_mode[0]==3){
+    if (rank_adaptation == 1)
+      rank_tm3_tm4 = rank_estimation_tm3_tm4(&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][0][4],
+                                             &ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][2][4],
+                                             &ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][1][4],
+                                             &ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][3][4],
+                                             N_RB_DL);
+    else
+      rank_tm3_tm4=1;
+#ifdef DEBUG_RANK_EST
+  printf("rank tm3 or tm4 %d\n", rank_tm3_tm4);
+#endif
+  }
+
+  if (ue->transmission_mode[eNB_id]!=4 && ue->transmission_mode[eNB_id]!=3)
+    ue->measurements.rank[eNB_id] = 0;
+  else
+    ue->measurements.rank[eNB_id] = rank_tm3_tm4;
+  //  printf ("tx mode %d\n", ue->transmission_mode[eNB_id]);
+  //  printf ("rank %d\n", ue->PHY_measurements.rank[eNB_id]);
+
+  // filter to remove jitter
+  if (ue->init_averaging == 0) {
+    for (eNB_id = 0; eNB_id < ue->n_connected_eNB; eNB_id++)
+      ue->measurements.rx_power_avg[eNB_id] = (int)
+          (((k1*((long long int)(ue->measurements.rx_power_avg[eNB_id]))) +
+            (k2*((long long int)(ue->measurements.rx_power_tot[eNB_id]))))>>10);
+
+    //LOG_I(PHY,"Noise Power Computation: k1 %d k2 %d n0 avg %d n0 tot %d\n", k1, k2, ue->measurements.n0_power_avg,
+    //    ue->measurements.n0_power_tot);
+    ue->measurements.n0_power_avg = (int)
+        (((k1*((long long int) (ue->measurements.n0_power_avg))) +
+          (k2*((long long int) (ue->measurements.n0_power_tot))))>>10);
+  } else {
+    for (eNB_id = 0; eNB_id < ue->n_connected_eNB; eNB_id++)
+      ue->measurements.rx_power_avg[eNB_id] = ue->measurements.rx_power_tot[eNB_id];
+
+    ue->measurements.n0_power_avg = ue->measurements.n0_power_tot;
+    ue->init_averaging = 0;
+  }
+  //printf("[UE %d] UE %d connected to eNB %d\n",ue->Mod_id,ue->n_connected_eNB,eNB_id);
+  for (eNB_id = 0; eNB_id < ue->n_connected_eNB; eNB_id++) {
+    ue->measurements.rx_power_avg_dB[eNB_id] = dB_fixed( ue->measurements.rx_power_avg[eNB_id]);
+    ue->measurements.wideband_cqi_tot[eNB_id] = dB_fixed2(ue->measurements.rx_power_tot[eNB_id],ue->measurements.n0_power_tot);
+    ue->measurements.wideband_cqi_avg[eNB_id] = dB_fixed2(ue->measurements.rx_power_avg[eNB_id],ue->measurements.n0_power_avg);
+    ue->measurements.rx_rssi_dBm[eNB_id] = ue->measurements.rx_power_avg_dB[eNB_id] - ue->rx_total_gain_dB;
+#ifdef DEBUG_MEAS_UE
+      LOG_I(PHY,"[eNB %d] Subframe %d, RSSI %d dBm, RSSI (digital) %d dB, WBandCQI %d dB, rxPwrAvg %d, n0PwrAvg %d\n",
+            eNB_id,
+            subframe,
+            ue->measurements.rx_rssi_dBm[eNB_id],
+            ue->measurements.rx_power_avg_dB[eNB_id],
+            ue->measurements.wideband_cqi_avg[eNB_id],
+            ue->measurements.rx_power_avg[eNB_id],
+            ue->measurements.n0_power_tot);
+#endif
+  }
+
+  ue->measurements.n0_power_avg_dB = dB_fixed( ue->measurements.n0_power_avg);
+
+  for (eNB_id = 0; eNB_id < ue->n_connected_eNB; eNB_id++) {
+    if (frame_parms->mode1_flag==0) {
+      // cqi/pmi information
+
+      for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+        dl_ch0    = &ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][aarx][4];
+        dl_ch1    = &ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][2+aarx][4];
+
+        for (subband=0; subband<nb_subbands; subband++) {
+
+          // cqi
+          if (aarx==0)
+            ue->measurements.subband_cqi_tot[eNB_id][subband]=0;
+
+          if ((subband<(nb_subbands-1))||(N_RB_DL==6)) {
+            /*for (i=0;i<48;i++)
+            msg("subband %d (%d) : %d,%d\n",subband,i,((short *)dl_ch0)[2*i],((short *)dl_ch0)[1+(2*i)]);
+            */
+            ue->measurements.subband_cqi[eNB_id][aarx][subband] =
+              (signal_energy_nodc(dl_ch0,subband_size) + signal_energy_nodc(dl_ch1,subband_size));
+
+            if ( ue->measurements.subband_cqi[eNB_id][aarx][subband] < 0)
+              ue->measurements.subband_cqi[eNB_id][aarx][subband]=0;
+
+            /*
+            else
+            ue->measurements.subband_cqi[eNB_id][aarx][subband]-=ue->measurements.n0_power[aarx];
+            */
+
+            ue->measurements.subband_cqi_tot[eNB_id][subband] += ue->measurements.subband_cqi[eNB_id][aarx][subband];
+            ue->measurements.subband_cqi_dB[eNB_id][aarx][subband] = dB_fixed2(ue->measurements.subband_cqi[eNB_id][aarx][subband],
+                ue->measurements.n0_power[aarx]);
+          } else { // this is for the last subband which is smaller in size
+            //      for (i=0;i<12;i++)
+            //        printf("subband %d (%d) : %d,%d\n",subband,i,((short *)dl_ch0)[2*i],((short *)dl_ch0)[1+(2*i)]);
+            ue->measurements.subband_cqi[eNB_id][aarx][subband] = (signal_energy_nodc(dl_ch0,last_subband_size) +
+                signal_energy_nodc(dl_ch1,last_subband_size)); // - ue->measurements.n0_power[aarx];
+            ue->measurements.subband_cqi_tot[eNB_id][subband] += ue->measurements.subband_cqi[eNB_id][aarx][subband];
+            ue->measurements.subband_cqi_dB[eNB_id][aarx][subband] = dB_fixed2(ue->measurements.subband_cqi[eNB_id][aarx][subband],
+                ue->measurements.n0_power[aarx]);
+          }
+
+          dl_ch1+=subband_size;
+          dl_ch0+=subband_size;
+          //    msg("subband_cqi[%d][%d][%d] => %d (%d dB)\n",eNB_id,aarx,subband,ue->measurements.subband_cqi[eNB_id][aarx][subband],ue->measurements.subband_cqi_dB[eNB_id][aarx][subband]);
+        }
+
+      }
+
+      for (subband=0; subband<nb_subbands; subband++) {
+        ue->measurements.subband_cqi_tot_dB[eNB_id][subband] = dB_fixed2(ue->measurements.subband_cqi_tot[eNB_id][subband],ue->measurements.n0_power_tot);
+        //    msg("subband_cqi_tot[%d][%d] => %d dB (n0 %d)\n",eNB_id,subband,ue->measurements.subband_cqi_tot_dB[eNB_id][subband],ue->measurements.n0_power_tot);
+      }
+
+      for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+        //printf("aarx=%d", aarx);
+        // skip the first 4 RE due to interpolation filter length of 5 (not possible to skip 5 due to 128i alignment, must be multiple of 128bit)
+
+#if defined(__x86_64__) || defined(__i386__)
+       __m128i pmi128_re,pmi128_im,mmtmpPMI0,mmtmpPMI1 /* ,mmtmpPMI2,mmtmpPMI3 */ ;
+
+        dl_ch0_128    = (__m128i *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][aarx][4];
+        dl_ch1_128    = (__m128i *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][2+aarx][4];
+#elif defined(__arm__)
+        int32x4_t pmi128_re,pmi128_im,mmtmpPMI0,mmtmpPMI1,mmtmpPMI0b,mmtmpPMI1b;
+
+        dl_ch0_128    = (int16x8_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][aarx][4];
+        dl_ch1_128    = (int16x8_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][2+aarx][4];
+
+#endif
+        for (subband=0; subband<nb_subbands; subband++) {
+
+
+          // pmi
+#if defined(__x86_64__) || defined(__i386__)
+
+          pmi128_re = _mm_xor_si128(pmi128_re,pmi128_re);
+          pmi128_im = _mm_xor_si128(pmi128_im,pmi128_im);
+#elif defined(__arm__)
+
+          pmi128_re = vdupq_n_s32(0);
+          pmi128_im = vdupq_n_s32(0);
+#endif
+          // limit is the number of groups of 4 REs in a subband (12 = 4 RBs, 3 = 1 RB)
+          // for 5 MHz channelization, there are 7 subbands, 6 of size 4 RBs and 1 of size 1 RB
+          if ((N_RB_DL==6) || (subband<(nb_subbands-1)))
+            limit = subband_size>>2;
+          else
+            limit = last_subband_size>>2;
+
+          for (i=0; i<limit; i++) {
+
+#if defined(__x86_64__) || defined(__i386__)
+              mmtmpPMI0 = _mm_xor_si128(mmtmpPMI0,mmtmpPMI0);
+              mmtmpPMI1 = _mm_xor_si128(mmtmpPMI1,mmtmpPMI1);
+
+            // For each RE in subband perform ch0 * conj(ch1)
+            // multiply by conjugated channel
+                //  print_ints("ch0",&dl_ch0_128[0]);
+                //  print_ints("ch1",&dl_ch1_128[0]);
+
+            mmtmpPMI0 = _mm_madd_epi16(dl_ch0_128[0],dl_ch1_128[0]);
+                 //  print_ints("re",&mmtmpPMI0);
+            mmtmpPMI1 = _mm_shufflelo_epi16(dl_ch1_128[0],_MM_SHUFFLE(2,3,0,1));
+              //  print_ints("_mm_shufflelo_epi16",&mmtmpPMI1);
+            mmtmpPMI1 = _mm_shufflehi_epi16(mmtmpPMI1,_MM_SHUFFLE(2,3,0,1));
+                //  print_ints("_mm_shufflehi_epi16",&mmtmpPMI1);
+            mmtmpPMI1 = _mm_sign_epi16(mmtmpPMI1,*(__m128i*)&conjugate[0]);
+               //  print_ints("_mm_sign_epi16",&mmtmpPMI1);
+            mmtmpPMI1 = _mm_madd_epi16(mmtmpPMI1,dl_ch0_128[0]);
+               //   print_ints("mm_madd_epi16",&mmtmpPMI1);
+            // mmtmpPMI1 contains imag part of 4 consecutive outputs (32-bit)
+            pmi128_re = _mm_add_epi32(pmi128_re,mmtmpPMI0);
+             //   print_ints(" pmi128_re 0",&pmi128_re);
+            pmi128_im = _mm_add_epi32(pmi128_im,mmtmpPMI1);
+               //   print_ints(" pmi128_im 0 ",&pmi128_im);
+
+          /*  mmtmpPMI0 = _mm_xor_si128(mmtmpPMI0,mmtmpPMI0);
+            mmtmpPMI1 = _mm_xor_si128(mmtmpPMI1,mmtmpPMI1);
+
+            mmtmpPMI0 = _mm_madd_epi16(dl_ch0_128[1],dl_ch1_128[1]);
+                 //  print_ints("re",&mmtmpPMI0);
+            mmtmpPMI1 = _mm_shufflelo_epi16(dl_ch1_128[1],_MM_SHUFFLE(2,3,0,1));
+              //  print_ints("_mm_shufflelo_epi16",&mmtmpPMI1);
+            mmtmpPMI1 = _mm_shufflehi_epi16(mmtmpPMI1,_MM_SHUFFLE(2,3,0,1));
+                //  print_ints("_mm_shufflehi_epi16",&mmtmpPMI1);
+            mmtmpPMI1 = _mm_sign_epi16(mmtmpPMI1,*(__m128i*)&conjugate);
+               //  print_ints("_mm_sign_epi16",&mmtmpPMI1);
+            mmtmpPMI1 = _mm_madd_epi16(mmtmpPMI1,dl_ch0_128[1]);
+               //   print_ints("mm_madd_epi16",&mmtmpPMI1);
+            // mmtmpPMI1 contains imag part of 4 consecutive outputs (32-bit)
+            pmi128_re = _mm_add_epi32(pmi128_re,mmtmpPMI0);
+                //  print_ints(" pmi128_re 1",&pmi128_re);
+            pmi128_im = _mm_add_epi32(pmi128_im,mmtmpPMI1);
+            //print_ints(" pmi128_im 1 ",&pmi128_im);*/
+
+#elif defined(__arm__)
+
+            mmtmpPMI0 = vmull_s16(((int16x4_t*)dl_ch0_128)[0], ((int16x4_t*)dl_ch1_128)[0]);
+            mmtmpPMI1 = vmull_s16(((int16x4_t*)dl_ch0_128)[1], ((int16x4_t*)dl_ch1_128)[1]);
+            pmi128_re = vqaddq_s32(pmi128_re,vcombine_s32(vpadd_s32(vget_low_s32(mmtmpPMI0),vget_high_s32(mmtmpPMI0)),vpadd_s32(vget_low_s32(mmtmpPMI1),vget_high_s32(mmtmpPMI1))));
+
+            mmtmpPMI0b = vmull_s16(vrev32_s16(vmul_s16(((int16x4_t*)dl_ch0_128)[0],*(int16x4_t*)conjugate)), ((int16x4_t*)dl_ch1_128)[0]);
+            mmtmpPMI1b = vmull_s16(vrev32_s16(vmul_s16(((int16x4_t*)dl_ch0_128)[1],*(int16x4_t*)conjugate)), ((int16x4_t*)dl_ch1_128)[1]);
+            pmi128_im = vqaddq_s32(pmi128_im,vcombine_s32(vpadd_s32(vget_low_s32(mmtmpPMI0b),vget_high_s32(mmtmpPMI0b)),vpadd_s32(vget_low_s32(mmtmpPMI1b),vget_high_s32(mmtmpPMI1b))));
+
+#endif
+            dl_ch0_128++;
+            dl_ch1_128++;
+          }
+
+          ue->measurements.subband_pmi_re[eNB_id][subband][aarx] = (((int *)&pmi128_re)[0] + ((int *)&pmi128_re)[1] + ((int *)&pmi128_re)[2] + ((int *)&pmi128_re)[3])>>2;
+          ue->measurements.subband_pmi_im[eNB_id][subband][aarx] = (((int *)&pmi128_im)[0] + ((int *)&pmi128_im)[1] + ((int *)&pmi128_im)[2] + ((int *)&pmi128_im)[3])>>2;
+          ue->measurements.wideband_pmi_re[eNB_id][aarx] += ue->measurements.subband_pmi_re[eNB_id][subband][aarx];
+          ue->measurements.wideband_pmi_im[eNB_id][aarx] += ue->measurements.subband_pmi_im[eNB_id][subband][aarx];
+        } // subband loop
+      } // rx antenna loop
+    }  // if frame_parms->mode1_flag == 0
+    else {
+      // cqi information only for mode 1
+      for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+        dl_ch0    = &ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][aarx][4];
+
+        for (subband=0; subband<7; subband++) {
+
+          // cqi
+          if (aarx==0)
+            ue->measurements.subband_cqi_tot[eNB_id][subband]=0;
+
+          if (subband<6) {
+            //      for (i=0;i<48;i++)
+            //        printf("subband %d (%d) : %d,%d\n",subband,i,((short *)dl_ch0)[2*i],((short *)dl_ch0)[1+(2*i)]);
+            ue->measurements.subband_cqi[eNB_id][aarx][subband] =
+              (signal_energy_nodc(dl_ch0,48) ) - ue->measurements.n0_power[aarx];
+
+            ue->measurements.subband_cqi_tot[eNB_id][subband] += ue->measurements.subband_cqi[eNB_id][aarx][subband];
+            ue->measurements.subband_cqi_dB[eNB_id][aarx][subband] = dB_fixed2(ue->measurements.subband_cqi[eNB_id][aarx][subband],
+                ue->measurements.n0_power[aarx]);
+          } else {
+            //      for (i=0;i<12;i++)
+            //        printf("subband %d (%d) : %d,%d\n",subband,i,((short *)dl_ch0)[2*i],((short *)dl_ch0)[1+(2*i)]);
+            ue->measurements.subband_cqi[eNB_id][aarx][subband] = (signal_energy_nodc(dl_ch0,12) ) - ue->measurements.n0_power[aarx];
+            ue->measurements.subband_cqi_tot[eNB_id][subband] += ue->measurements.subband_cqi[eNB_id][aarx][subband];
+            ue->measurements.subband_cqi_dB[eNB_id][aarx][subband] = dB_fixed2(ue->measurements.subband_cqi[eNB_id][aarx][subband],
+                ue->measurements.n0_power[aarx]);
+          }
+
+          dl_ch1+=48;
+          //    msg("subband_cqi[%d][%d][%d] => %d (%d dB)\n",eNB_id,aarx,subband,ue->measurements.subband_cqi[eNB_id][aarx][subband],ue->measurements.subband_cqi_dB[eNB_id][aarx][subband]);
+        }
+      }
+
+      for (subband=0; subband<nb_subbands; subband++) {
+        ue->measurements.subband_cqi_tot_dB[eNB_id][subband] = dB_fixed2(ue->measurements.subband_cqi_tot[eNB_id][subband],ue->measurements.n0_power_tot);
+      }
+    }
+
+    //ue->measurements.rank[eNB_id] = 0;
+
+    for (i=0; i<nb_subbands; i++) {
+      ue->measurements.selected_rx_antennas[eNB_id][i] = 0;
+
+      if (frame_parms->nb_antennas_rx>1) {
+        if (ue->measurements.subband_cqi_dB[eNB_id][0][i] >= ue->measurements.subband_cqi_dB[eNB_id][1][i])
+          ue->measurements.selected_rx_antennas[eNB_id][i] = 0;
+        else
+          ue->measurements.selected_rx_antennas[eNB_id][i] = 1;
+      } else
+        ue->measurements.selected_rx_antennas[eNB_id][i] = 0;
+    }
+
+    // if(eNB_id==0)
+    // printf("in lte_ue_measurements: selected rx_antenna[eNB_id==0]:%u\n", ue->measurements.selected_rx_antennas[eNB_id][i]);
+  }  // eNB_id loop
+
+#if defined(__x86_64__) || defined(__i386__)
+  _mm_empty();
+  _m_empty();
+#endif
+}
 
 void lte_ue_measurements_emul(PHY_VARS_UE *ue,uint8_t subframe,uint8_t eNB_id)
 {

openair1/PHY/LTE_TRANSPORT/initial_sync.c

@@ -79,7 +79,6 @@ int pbch_detection(PHY_VARS_UE *ue, runmode_t mode)
 	   ue->rx_offset,
 	   0,
 	   1);
-
   lte_ue_measurements(ue,
 		      ue->rx_offset,
 		      0,
@@ -87,7 +86,7 @@ int pbch_detection(PHY_VARS_UE *ue, runmode_t mode)
 		      0,
                       0);
 
-
+  printf("after lte_ue_measurements:TDD? %d UE %d, dig %3.1f\n",ue->frame_parms.frame_type,ue->Mod_id,10*log10(ue->measurements.rssi));
   if (ue->frame_parms.frame_type == TDD) {
     ue_rrc_measurements(ue,
 			2,
@@ -98,7 +97,8 @@ int pbch_detection(PHY_VARS_UE *ue, runmode_t mode)
 			0,
 			0);
   }
-#ifdef DEBUG_INITIAL_SYNCH
+  printf(" after ue_rrc_measurements_freq: UE %d, dig %3.1f\n",ue->Mod_id,10*log10(ue->measurements.rssi));
+//#ifdef DEBUG_INITIAL_SYNCH
   LOG_I(PHY,"[UE %d] RX RSSI %d dBm, digital (%d, %d) dB, linear (%d, %d), avg rx power %d dB (%d lin), RX gain %d dB\n",
         ue->Mod_id,
         ue->measurements.rx_rssi_dBm[0] - ((ue->frame_parms.nb_antennas_rx==2) ? 3 : 0),
@@ -119,7 +119,7 @@ int pbch_detection(PHY_VARS_UE *ue, runmode_t mode)
         ue->measurements.n0_power[1],
         ue->measurements.n0_power_avg_dB,
         ue->measurements.n0_power_avg);
-#endif
+//#endif
 
   pbch_decoded = 0;
 
@@ -244,7 +244,7 @@ int pbch_detection(PHY_VARS_UE *ue, runmode_t mode)
 #endif
         ue->proc.proc_rxtx[i].frame_tx = ue->proc.proc_rxtx[0].frame_rx;
     }
-#ifdef DEBUG_INITIAL_SYNCH
+//#ifdef DEBUG_INITIAL_SYNCH
     LOG_I(PHY,"[UE%d] Initial sync: pbch decoded sucessfully mode1_flag %d, tx_ant %d, frame %d, N_RB_DL %d, phich_duration %d, phich_resource %s!\n",
           ue->Mod_id,
           frame_parms->mode1_flag,
@@ -253,7 +253,7 @@ int pbch_detection(PHY_VARS_UE *ue, runmode_t mode)
           frame_parms->N_RB_DL,
           frame_parms->phich_config_common.phich_duration,
           phich_resource);  //frame_parms->phich_config_common.phich_resource);
-#endif
+//#endif
     return(0);
   } else {
     return(-1);
@@ -297,13 +297,13 @@ int pbch_detection_freq(PHY_VARS_UE *ue, runmode_t mode)
 	   0,
 	   1);
 
-  lte_ue_measurements(ue,
+  lte_ue_measurements_freq(ue,
 		      ue->rx_offset,
 		      0,
                       0,
 		      0,
                       0);
-
+  printf(" after lte_ue_measurements_freq: UE %d, dig %3.1f\n",ue->Mod_id,10*log10(ue->measurements.rssi));
 
   if (ue->frame_parms.frame_type == TDD) {
     ue_rrc_measurements_freq(ue,
@@ -315,7 +315,8 @@ int pbch_detection_freq(PHY_VARS_UE *ue, runmode_t mode)
 			0,
 			0);
   }
-#ifdef DEBUG_INITIAL_SYNCH
+  printf(" after ue_rrc_measurements_freq: TDD? %d UE %d, dig %3.1f\n",ue->frame_parms.frame_type,ue->Mod_id,10*log10(ue->measurements.rssi));
+//#ifdef DEBUG_INITIAL_SYNCH
   LOG_I(PHY,"[UE %d] RX RSSI %d dBm, digital (%d, %d) dB, linear (%d, %d), avg rx power %d dB (%d lin), RX gain %d dB\n",
         ue->Mod_id,
         ue->measurements.rx_rssi_dBm[0] - ((ue->frame_parms.nb_antennas_rx==2) ? 3 : 0),
@@ -336,7 +337,7 @@ int pbch_detection_freq(PHY_VARS_UE *ue, runmode_t mode)
         ue->measurements.n0_power[1],
         ue->measurements.n0_power_avg_dB,
         ue->measurements.n0_power_avg);
-#endif
+//#endif
 
   pbch_decoded = 0;
 
@@ -461,7 +462,7 @@ int pbch_detection_freq(PHY_VARS_UE *ue, runmode_t mode)
 #endif
         ue->proc.proc_rxtx[i].frame_tx = ue->proc.proc_rxtx[0].frame_rx;
     }
-#ifdef DEBUG_INITIAL_SYNCH
+//#ifdef DEBUG_INITIAL_SYNCH
     LOG_I(PHY,"[UE%d] Initial sync: pbch decoded sucessfully mode1_flag %d, tx_ant %d, frame %d, N_RB_DL %d, phich_duration %d, phich_resource %s!\n",
           ue->Mod_id,
           frame_parms->mode1_flag,
@@ -470,7 +471,7 @@ int pbch_detection_freq(PHY_VARS_UE *ue, runmode_t mode)
           frame_parms->N_RB_DL,
           frame_parms->phich_config_common.phich_duration,
           phich_resource);  //frame_parms->phich_config_common.phich_resource);
-#endif
+//#endif
     return(0);
   } else {
     return(-1);
@@ -732,8 +733,9 @@ int initial_sync(PHY_VARS_UE *ue, runmode_t mode)
     }
 
 #if DISABLE_LOG_X
-    printf("[UE %d] Frame %d RRC Measurements => rssi %3.1f dBm (dig %3.1f dB, gain %d), N0 %d dBm,  rsrp %3.1f dBm/RE, rsrq %3.1f dB\n",ue->Mod_id,
+    printf("[UE %d] Frame %d subframe %d RRC Measurements => rssi %3.1f dBm (dig %3.1f dB, gain %d), N0 %d dBm,  rsrp %3.1f dBm/RE, rsrq %3.1f dB\n",ue->Mod_id,
 	  ue->proc.proc_rxtx[0].frame_rx,
+	  ue->proc.proc_rxtx[0].subframe_rx,
 	  10*log10(ue->measurements.rssi)-ue->rx_total_gain_dB,
 	  10*log10(ue->measurements.rssi),
 	  ue->rx_total_gain_dB,
@@ -742,9 +744,10 @@ int initial_sync(PHY_VARS_UE *ue, runmode_t mode)
 	  (10*log10(ue->measurements.rsrq[0])));
 
 
-    printf("[UE %d] Frame %d MIB Information => %s, %s, NidCell %d, N_RB_DL %d, PHICH DURATION %d, PHICH RESOURCE %s, TX_ANT %d\n",
+    printf("[UE %d] Frame %d subframe %d MIB Information => %s, %s, NidCell %d, N_RB_DL %d, PHICH DURATION %d, PHICH RESOURCE %s, TX_ANT %d\n",
 	  ue->Mod_id,
 	  ue->proc.proc_rxtx[0].frame_rx,
+	  ue->proc.proc_rxtx[0].subframe_rx,
 	  duplex_string[ue->frame_parms.frame_type],
 	  prefix_string[ue->frame_parms.Ncp],
 	  ue->frame_parms.Nid_cell,
@@ -753,8 +756,9 @@ int initial_sync(PHY_VARS_UE *ue, runmode_t mode)
 	  phich_string[ue->frame_parms.phich_config_common.phich_resource],
 	  ue->frame_parms.nb_antenna_ports_eNB);
 #else
-    LOG_I(PHY, "[UE %d] Frame %d RRC Measurements => rssi %3.1f dBm (dig %3.1f dB, gain %d), N0 %d dBm,  rsrp %3.1f dBm/RE, rsrq %3.1f dB\n",ue->Mod_id,
+    LOG_I(PHY, "[UE %d] Frame %d subframe %d RRC Measurements => rssi %3.1f dBm (dig %3.1f dB, gain %d), N0 %d dBm,  rsrp %3.1f dBm/RE, rsrq %3.1f dB\n",ue->Mod_id,
 	  ue->proc.proc_rxtx[0].frame_rx,
+	  ue->proc.proc_rxtx[0].subframe_rx,
 	  10*log10(ue->measurements.rssi)-ue->rx_total_gain_dB,
 	  10*log10(ue->measurements.rssi),
 	  ue->rx_total_gain_dB,
@@ -762,9 +766,10 @@ int initial_sync(PHY_VARS_UE *ue, runmode_t mode)
 	  10*log10(ue->measurements.rsrp[0])-ue->rx_total_gain_dB,
 	  (10*log10(ue->measurements.rsrq[0])));
 
-    LOG_I(PHY, "[UE %d] Frame %d MIB Information => %s, %s, NidCell %d, N_RB_DL %d, PHICH DURATION %d, PHICH RESOURCE %s, TX_ANT %d\n",
+    LOG_I(PHY, "[UE %d] Frame %d subframe %d MIB Information => %s, %s, NidCell %d, N_RB_DL %d, PHICH DURATION %d, PHICH RESOURCE %s, TX_ANT %d\n",
 	  ue->Mod_id,
 	  ue->proc.proc_rxtx[0].frame_rx,
+	  ue->proc.proc_rxtx[0].subframe_rx,
 	  duplex_string[ue->frame_parms.frame_type],
 	  prefix_string[ue->frame_parms.Ncp],
 	  ue->frame_parms.Nid_cell,
@@ -772,6 +777,17 @@ int initial_sync(PHY_VARS_UE *ue, runmode_t mode)
 	  ue->frame_parms.phich_config_common.phich_duration,
 	  phich_string[ue->frame_parms.phich_config_common.phich_resource],
 	  ue->frame_parms.nb_antenna_ports_eNB);
+    LOG_I(PHY,"[eNB %d] Frame %d subframe %d MIB Information => %s, %s, NidCell %d, N_RB_DL %d, PHICH DURATION %d, PHICH RESOURCE %s, TX_ANT %d\n",
+	  PHY_vars_eNB_g[0][0]->Mod_id,
+	  PHY_vars_eNB_g[0][0]->proc.proc_rxtx[0].frame_rx,
+	  PHY_vars_eNB_g[0][0]->proc.proc_rxtx[0].subframe_rx,
+	  duplex_string[PHY_vars_eNB_g[0][0]->frame_parms.frame_type],
+	  prefix_string[PHY_vars_eNB_g[0][0]->frame_parms.Ncp],
+	  PHY_vars_eNB_g[0][0]->frame_parms.Nid_cell,
+	  PHY_vars_eNB_g[0][0]->frame_parms.N_RB_DL,
+	  PHY_vars_eNB_g[0][0]->frame_parms.phich_config_common.phich_duration,
+	  phich_string[PHY_vars_eNB_g[0][0]->frame_parms.phich_config_common.phich_resource],
+	  PHY_vars_eNB_g[0][0]->frame_parms.nb_antenna_ports_eNB);
 #endif
 
 #if defined(OAI_USRP) || defined(EXMIMO) || defined(OAI_BLADERF) || defined(OAI_LMSSDR)
@@ -813,12 +829,12 @@ int initial_sync(PHY_VARS_UE *ue, runmode_t mode)
   // gain control
   if (ret!=0) { //we are not synched, so we cannot use rssi measurement (which is based on channel estimates)
     rx_power = 0;
-
+    printf("Point start PSS: %d\n",sync_pos2);
     // do a measurement on the best guess of the PSS
     for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++)
       rx_power += signal_energy(&ue->common_vars.rxdata[aarx][sync_pos2],
 				frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples);
-
+    printf("rx_power %d\n",rx_power);
     /*
     // do a measurement on the full frame
     for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++)
@@ -839,6 +855,7 @@ int initial_sync(PHY_VARS_UE *ue, runmode_t mode)
 #ifndef OAI_BLADERF
 #ifndef OAI_LMSSDR
   phy_adjust_gain(ue,ue->measurements.rx_power_avg_dB[0],0);
+  printf("adjust gain 1\n");
 #endif
 #endif
 #endif
@@ -850,6 +867,7 @@ int initial_sync(PHY_VARS_UE *ue, runmode_t mode)
 #ifndef OAI_BLADERF
 #ifndef OAI_LMSSDR
   phy_adjust_gain(ue,dB_fixed(ue->measurements.rssi),0);
+  printf("adjust gain 2\n");
 #endif
 #endif
 #endif
@@ -869,6 +887,7 @@ int initial_sync_freq(PHY_VARS_UE *ue, runmode_t mode)
   LTE_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
   int ret=-1;
   int aarx,rx_power=0;
+  printf("initial_synch_freq: id %d\n",ue->Mod_id);
   /*#ifdef OAI_USRP
   __m128i *rxdata128;
   #endif*/
@@ -877,10 +896,10 @@ int initial_sync_freq(PHY_VARS_UE *ue, runmode_t mode)
   // First try FDD normal prefix
   //frame_parms->Ncp=NORMAL;
   //frame_parms->frame_type=FDD;
-  frame_parms->frame_type=PHY_vars_eNB_g[0][0]->frame_parms.frame_type;
   frame_parms->Ncp=PHY_vars_eNB_g[0][0]->frame_parms.Ncp;
+  frame_parms->frame_type=PHY_vars_eNB_g[0][0]->frame_parms.frame_type;
+  frame_parms->N_RB_DL=PHY_vars_eNB_g[0][0]->frame_parms.N_RB_DL;
   init_frame_parms(frame_parms,1);
-  //frame_parms->N_RB_DL=PHY_vars_eNB_g[0][0]->frame_parms.N_RB_DL;
 
 // cellid
   frame_parms->Nid_cell=PHY_vars_eNB_g[0][0]->frame_parms.Nid_cell;
@@ -896,12 +915,13 @@ int initial_sync_freq(PHY_VARS_UE *ue, runmode_t mode)
   //printf("dumping ue frame params\n");
   //dump_frame_parms(frame_parms);
   if (ret==-1) { 
-      frame_parms->frame_type=PHY_vars_eNB_g[0][0]->frame_parms.frame_type;
       frame_parms->Ncp=PHY_vars_eNB_g[0][0]->frame_parms.Ncp;
+      frame_parms->frame_type=PHY_vars_eNB_g[0][0]->frame_parms.frame_type;
+      frame_parms->N_RB_DL=PHY_vars_eNB_g[0][0]->frame_parms.N_RB_DL;
       init_frame_parms(frame_parms,1);
       frame_parms->nushift  = frame_parms->Nid_cell%6;
       lte_gold(frame_parms,ue->lte_gold_table[0],frame_parms->Nid_cell);
-      ret = pbch_detection(ue,mode);
+      ret = pbch_detection_freq(ue,mode);
 
   }
   if (ret==0) {  // fake first PBCH found so indicate sync to higher layers and configure frame parameters
@@ -944,8 +964,9 @@ int initial_sync_freq(PHY_VARS_UE *ue, runmode_t mode)
 
     }
 
-    LOG_I(PHY,"[UE %d] Frame %d RRC Measurements => rssi %3.1f dBm (dig %3.1f dB, gain %d), N0 %d dBm,  rsrp %3.1f dBm/RE, rsrq %3.1f dB\n",ue->Mod_id,
+    LOG_I(PHY,"[UE %d] Frame %d subframe %d RRC Measurements => rssi %3.1f dBm (dig %3.1f dB, gain %d), N0 %d dBm,  rsrp %3.1f dBm/RE, rsrq %3.1f dB\n",ue->Mod_id,
 	  ue->proc.proc_rxtx[0].frame_rx,
+	  ue->proc.proc_rxtx[0].subframe_rx,
 	  10*log10(ue->measurements.rssi)-ue->rx_total_gain_dB,
 	  10*log10(ue->measurements.rssi),
 	  ue->rx_total_gain_dB,
@@ -953,9 +974,10 @@ int initial_sync_freq(PHY_VARS_UE *ue, runmode_t mode)
 	  10*log10(ue->measurements.rsrp[0])-ue->rx_total_gain_dB,
 	  (10*log10(ue->measurements.rsrq[0])));
 
-    LOG_I(PHY,"[UE %d] Frame %d MIB Information => %s, %s, NidCell %d, N_RB_DL %d, PHICH DURATION %d, PHICH RESOURCE %s, TX_ANT %d\n",
+    LOG_I(PHY,"[UE %d] Frame %d subframe %d MIB Information => %s, %s, NidCell %d, N_RB_DL %d, PHICH DURATION %d, PHICH RESOURCE %s, TX_ANT %d\n",
 	  ue->Mod_id,
 	  ue->proc.proc_rxtx[0].frame_rx,
+	  ue->proc.proc_rxtx[0].subframe_rx,
 	  duplex_string[ue->frame_parms.frame_type],
 	  prefix_string[ue->frame_parms.Ncp],
 	  ue->frame_parms.Nid_cell,
@@ -963,9 +985,10 @@ int initial_sync_freq(PHY_VARS_UE *ue, runmode_t mode)
 	  ue->frame_parms.phich_config_common.phich_duration,
 	  phich_string[ue->frame_parms.phich_config_common.phich_resource],
 	  ue->frame_parms.nb_antenna_ports_eNB);
-    LOG_I(PHY,"[eNB %d] Frame %d MIB Information => %s, %s, NidCell %d, N_RB_DL %d, PHICH DURATION %d, PHICH RESOURCE %s, TX_ANT %d\n",
+    LOG_I(PHY,"[eNB %d] Frame %d subframe %d MIB Information => %s, %s, NidCell %d, N_RB_DL %d, PHICH DURATION %d, PHICH RESOURCE %s, TX_ANT %d\n",
 	  PHY_vars_eNB_g[0][0]->Mod_id,
 	  PHY_vars_eNB_g[0][0]->proc.proc_rxtx[0].frame_rx,
+	  PHY_vars_eNB_g[0][0]->proc.proc_rxtx[0].subframe_rx,
 	  duplex_string[PHY_vars_eNB_g[0][0]->frame_parms.frame_type],
 	  prefix_string[PHY_vars_eNB_g[0][0]->frame_parms.Ncp],
 	  PHY_vars_eNB_g[0][0]->frame_parms.Nid_cell,
@@ -980,13 +1003,6 @@ int initial_sync_freq(PHY_VARS_UE *ue, runmode_t mode)
 	  ue->proc.proc_rxtx[0].frame_rx,
 	  openair0_cfg[0].rx_freq[0]-ue->common_vars.freq_offset,
 	  ue->common_vars.freq_offset);
-#endif
-#ifndef OAI_USRP
-#ifndef OAI_BLADERF
-#ifndef OAI_LMSSDR
-  	  phy_adjust_gain(ue,dB_fixed(ue->measurements.rssi),0);
-#endif
-#endif
 #endif
   } else {
 #ifdef DEBUG_INITIAL_SYNC
@@ -1007,6 +1023,54 @@ int initial_sync_freq(PHY_VARS_UE *ue, runmode_t mode)
     ue->pbch_vars[0]->pdu_errors++;
     ue->pbch_vars[0]->pdu_errors_conseq++;
 
+  }
+  // gain control
+  if (ret!=0) { //we are not synched, so we cannot use rssi measurement (which is based on channel estimates)
+    rx_power = 0;
+    printf("(6144?) Point start PSS: %d\n",6*frame_parms->ofdm_symbol_size);
+    // do a measurement on the best guess of the PSS
+    for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++)
+      rx_power=0;// += signal_energy((int*)&ue->common_vars.common_vars_rx_data_per_thread[0].rxdataF[aarx][6*frame_parms->ofdm_symbol_size],
+				//frame_parms->ofdm_symbol_size);
+   printf("rx_power %d\n",rx_power);
+
+    /*common_vars.common_vars_rx_data_per_thread[0].rxdataF
+    // do a measurement on the full frame
+    for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++)
+      rx_power += signal_energy(&ue->common_vars.rxdata[aarx][0],
+				frame_parms->samples_per_tti*10);
+    */
+
+    // we might add a low-pass filter here later
+    ue->measurements.rx_power_avg[0] = rx_power/frame_parms->nb_antennas_rx;
+
+    ue->measurements.rx_power_avg_dB[0] = dB_fixed(ue->measurements.rx_power_avg[0]);
+
+#ifdef DEBUG_INITIAL_SYNCH
+  LOG_I(PHY,"[UE%d] Initial sync : Estimated power: %d dB\n",ue->Mod_id,ue->measurements.rx_power_avg_dB[0] );
+#endif
+
+#ifndef OAI_USRP
+#ifndef OAI_BLADERF
+#ifndef OAI_LMSSDR
+  phy_adjust_gain(ue,ue->measurements.rx_power_avg_dB[0],0);
+  printf("adjust gain freq 1\n");
+#endif
+#endif
+#endif
+
+  }
+  else {
+
+#ifndef OAI_USRP
+#ifndef OAI_BLADERF
+#ifndef OAI_LMSSDR
+  phy_adjust_gain(ue,dB_fixed(ue->measurements.rssi),0);
+  printf("adjust gain freq 2\n");
+#endif
+#endif
+#endif
+
   }
   
   return ret;

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;