Addition of UE TX in USRP (still under test), calibration of UE RX for 5/10/20...

Addition of UE TX in USRP (still under test), calibration of UE RX for 5/10/20 MHz with USRP, new noise and signal power estimation for UE- RK

git-svn-id: http://svn.eurecom.fr/openair4G/trunk@6609 818b1a75-f10b-46b9-bf7c-635c3b92a50f

openair1/PHY/LTE_ESTIMATION/lte_ue_measurements.c

@@ -159,7 +159,7 @@ void ue_rrc_measurements(PHY_VARS_UE *phy_vars_ue,
 			 uint8_t abstraction_flag) {
 
   int aarx,rb;
-  int16_t *rxF;
+  int16_t *rxF,*rxF_pss,*rxF_sss;
 
   uint16_t Nid_cell = phy_vars_ue->lte_frame_parms.Nid_cell;
   uint8_t eNB_offset,nu,l,nushift,k;
@@ -168,8 +168,53 @@ void ue_rrc_measurements(PHY_VARS_UE *phy_vars_ue,
 
   for (eNB_offset = 0;eNB_offset<1+phy_vars_ue->PHY_measurements.n_adj_cells;eNB_offset++) {
 
-    if (eNB_offset==0)
+    if (eNB_offset==0) {
       phy_vars_ue->PHY_measurements.rssi = 0;
+      phy_vars_ue->PHY_measurements.n0_power_tot = 0;
+
+      if ((phy_vars_ue->lte_frame_parms.frame_type == FDD) && 
+	  ((slot == 0) || (slot == 10))) {  // FDD PSS/SSS, compute noise in DTX REs
+	    if (phy_vars_ue->lte_frame_parms.Ncp==NORMAL) {
+	      for (aarx=0;aarx<phy_vars_ue->lte_frame_parms.nb_antennas_rx;aarx++) {
+
+		rxF_sss = (int16_t *)&phy_vars_ue->lte_ue_common_vars.rxdataF[aarx][(5*phy_vars_ue->lte_frame_parms.ofdm_symbol_size)];
+		rxF_pss = (int16_t *)&phy_vars_ue->lte_ue_common_vars.rxdataF[aarx][(6*phy_vars_ue->lte_frame_parms.ofdm_symbol_size)];
+
+		
+		//-ve spectrum from SSS
+		phy_vars_ue->PHY_measurements.n0_power[aarx] = ((rxF_pss[-72]*rxF_pss[-72])+(rxF_pss[-71]*rxF_pss[-71]));
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_pss[-70]*rxF_pss[-70])+(rxF_pss[-69]*rxF_pss[-69]));
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_pss[-68]*rxF_pss[-68])+(rxF_pss[-67]*rxF_pss[-67]));
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_pss[-66]*rxF_pss[-66])+(rxF_pss[-65]*rxF_pss[-65]));
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_pss[-64]*rxF_pss[-64])+(rxF_pss[-63]*rxF_pss[-63]));
+		//+ve spectrum from SSS
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_sss[2+72]*rxF_sss[2+72])+(rxF_sss[2+71]*rxF_sss[2+71]));
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_sss[2+70]*rxF_sss[2+70])+(rxF_sss[2+69]*rxF_sss[2+69]));
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_sss[2+68]*rxF_sss[2+68])+(rxF_sss[2+67]*rxF_sss[2+67]));
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_sss[2+66]*rxF_sss[2+66])+(rxF_sss[2+65]*rxF_sss[2+65]));
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_sss[2+64]*rxF_sss[2+64])+(rxF_sss[2+63]*rxF_sss[2+63]));
+		//+ve spectrum from PSS
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_pss[2+72]*rxF_pss[2+72])+(rxF_pss[2+71]*rxF_pss[2+71]));
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_pss[2+70]*rxF_pss[2+70])+(rxF_pss[2+69]*rxF_pss[2+69]));
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_pss[2+68]*rxF_pss[2+68])+(rxF_pss[2+67]*rxF_pss[2+67]));
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_pss[2+66]*rxF_pss[2+66])+(rxF_pss[2+65]*rxF_pss[2+65]));
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_pss[2+64]*rxF_pss[2+64])+(rxF_pss[2+63]*rxF_pss[2+63]));	  
+		//-ve spectrum from PSS
+		rxF_pss = (int16_t *)&phy_vars_ue->lte_ue_common_vars.rxdataF[aarx][(7*phy_vars_ue->lte_frame_parms.ofdm_symbol_size)];
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_pss[-72]*rxF_pss[-72])+(rxF_pss[-71]*rxF_pss[-71]));
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_pss[-70]*rxF_pss[-70])+(rxF_pss[-69]*rxF_pss[-69]));
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_pss[-68]*rxF_pss[-68])+(rxF_pss[-67]*rxF_pss[-67]));
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_pss[-66]*rxF_pss[-66])+(rxF_pss[-65]*rxF_pss[-65]));
+		phy_vars_ue->PHY_measurements.n0_power[aarx] += ((rxF_pss[-64]*rxF_pss[-64])+(rxF_pss[-63]*rxF_pss[-63]));
+		phy_vars_ue->PHY_measurements.n0_power_dB[aarx] = (unsigned short) dB_fixed(phy_vars_ue->PHY_measurements.n0_power[aarx]/10);
+		phy_vars_ue->PHY_measurements.n0_power_tot +=  phy_vars_ue->PHY_measurements.n0_power[aarx];
+	      }
+	      phy_vars_ue->PHY_measurements.n0_power_tot_dB = (unsigned short) dB_fixed(phy_vars_ue->PHY_measurements.n0_power_tot/20);
+	      phy_vars_ue->PHY_measurements.n0_power_tot_dBm = phy_vars_ue->PHY_measurements.n0_power_tot_dB - phy_vars_ue->rx_total_gain_dB;
+
+	    } 
+      }
+    }
 
 #ifdef DEBUG_MEAS
     LOG_D(PHY,"ue_rrc_measurements: eNB_offset %d => rssi %d\n",eNB_offset,phy_vars_ue->PHY_measurements.rssi);
@@ -206,13 +251,22 @@ void ue_rrc_measurements(PHY_VARS_UE *phy_vars_ue,
 		//	  printf("rb %d, off %d, off2 %d\n",rb,off,off2);
 		
 		phy_vars_ue->PHY_measurements.rsrp[eNB_offset] += ((rxF[off]*rxF[off])+(rxF[off+1]*rxF[off+1]));
+		/*		if ((phy_vars_ue->frame_rx&0x3ff) == 0)
+		  printf("rb %d, off %d : %d\n",rb,off,((rxF[off]*rxF[off])+(rxF[off+1]*rxF[off+1])));
+		
+		*/
 		off+=12;
 		if (off>=(phy_vars_ue->lte_frame_parms.ofdm_symbol_size<<1))
 		  off = (1+k)<<1;
 		phy_vars_ue->PHY_measurements.rsrp[eNB_offset] += ((rxF[off]*rxF[off])+(rxF[off+1]*rxF[off+1]));
+		/*
+		  if ((phy_vars_ue->frame_rx&0x3ff) == 0)
+		  printf("rb %d, off %d : %d\n",rb,off,((rxF[off]*rxF[off])+(rxF[off+1]*rxF[off+1])));
+		*/
 		off+=12;
 		if (off>=(phy_vars_ue->lte_frame_parms.ofdm_symbol_size<<1))
 		  off = (1+k)<<1;
+
 	      }
 	  
 	      /*
@@ -232,14 +286,16 @@ void ue_rrc_measurements(PHY_VARS_UE *phy_vars_ue,
 
 //      LOG_D(PHY,"eNB: %d, RSRP_tmp: %d \n",eNB_offset,phy_vars_ue->PHY_measurements.rsrp[eNB_offset]);
       // 2 RE per PRB
-      phy_vars_ue->PHY_measurements.rsrp[eNB_offset]/=(24*phy_vars_ue->lte_frame_parms.N_RB_DL);
+      //      phy_vars_ue->PHY_measurements.rsrp[eNB_offset]/=(24*phy_vars_ue->lte_frame_parms.N_RB_DL);
+      phy_vars_ue->PHY_measurements.rsrp[eNB_offset]/=(2*phy_vars_ue->lte_frame_parms.N_RB_DL);
      
 
  
       if (eNB_offset == 0) {
 	//	phy_vars_ue->PHY_measurements.rssi/=(24*phy_vars_ue->lte_frame_parms.N_RB_DL);
 	//	phy_vars_ue->PHY_measurements.rssi*=rx_power_correction;
-	phy_vars_ue->PHY_measurements.rssi=phy_vars_ue->PHY_measurements.rsrp[0]*24/2;
+	//	phy_vars_ue->PHY_measurements.rssi=phy_vars_ue->PHY_measurements.rsrp[0]*24/2;
+	phy_vars_ue->PHY_measurements.rssi=phy_vars_ue->PHY_measurements.rsrp[0]*(12*phy_vars_ue->lte_frame_parms.N_RB_DL);
       }
       if (phy_vars_ue->PHY_measurements.rssi>0)
 	phy_vars_ue->PHY_measurements.rsrq[eNB_offset] = 100*phy_vars_ue->PHY_measurements.rsrp[eNB_offset]*phy_vars_ue->lte_frame_parms.N_RB_DL/phy_vars_ue->PHY_measurements.rssi;
@@ -318,6 +374,7 @@ void lte_ue_measurements(PHY_VARS_UE *phy_vars_ue,
       last_subband_size = 4*12;
       break;
     }
+    /*  // DONE NOW in ue_rrc_measurements
     if (abstraction_flag!=0) {
       phy_vars_ue->PHY_measurements.n0_power_tot = 0;
       for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
@@ -347,7 +404,7 @@ void lte_ue_measurements(PHY_VARS_UE *phy_vars_ue,
     else {
       phy_vars_ue->PHY_measurements.n0_power_tot_dBm = phy_vars_ue->PHY_measurements.n0_power_tot_dB - phy_vars_ue->rx_total_gain_dB + gain_offset;
     }
-
+    */
     // signal measurements  
     for (eNB_id=0;eNB_id<phy_vars_ue->n_connected_eNB;eNB_id++) {
       for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
@@ -401,7 +458,7 @@ void lte_ue_measurements(PHY_VARS_UE *phy_vars_ue,
       phy_vars_ue->PHY_measurements.rx_power_avg_dB[eNB_id] = dB_fixed( phy_vars_ue->PHY_measurements.rx_power_avg[eNB_id]);
       phy_vars_ue->PHY_measurements.wideband_cqi_tot[eNB_id] = dB_fixed2(phy_vars_ue->PHY_measurements.rx_power_tot[eNB_id],phy_vars_ue->PHY_measurements.n0_power_tot);
       phy_vars_ue->PHY_measurements.wideband_cqi_avg[eNB_id] = dB_fixed2(phy_vars_ue->PHY_measurements.rx_power_avg[eNB_id],phy_vars_ue->PHY_measurements.n0_power_avg);
-      phy_vars_ue->PHY_measurements.rx_rssi_dBm[eNB_id] = phy_vars_ue->PHY_measurements.rx_power_avg_dB[eNB_id] - phy_vars_ue->rx_total_gain_dB + gain_offset;
+      phy_vars_ue->PHY_measurements.rx_rssi_dBm[eNB_id] = phy_vars_ue->PHY_measurements.rx_power_avg_dB[eNB_id] - phy_vars_ue->rx_total_gain_dB;
 #ifdef DEBUG_MEAS
       LOG_D(PHY,"[eNB %d] lte_ue_measurements: RSSI %d dBm, RSSI (digital) %d dB\n",
 	     eNB_id,phy_vars_ue->PHY_measurements.rx_rssi_dBm[eNB_id],

openair1/PHY/LTE_TRANSPORT/print_stats.c

@@ -65,7 +65,7 @@ int dump_ue_stats(PHY_VARS_UE *phy_vars_ue, char* buffer, int length, runmode_t
 
   if ((mode == normal_txrx) || (mode == no_L2_connect)) {
   len += sprintf(&buffer[len], "[UE_PROC] UE %d, RNTI %x\n",phy_vars_ue->Mod_id, phy_vars_ue->lte_ue_pdcch_vars[0]->crnti);
-  len += sprintf(&buffer[len], "[UE PROC] Frame count: %d\neNB0 RSSI %d dBm (%d dB, %d dB)\neNB1 RSSI %d dBm (%d dB, %d dB)\neNB2 RSSI %d dBm (%d dB, %d dB)\nN0 %d dBm (%d dB, %d dB)\n",
+  len += sprintf(&buffer[len], "[UE PROC] Frame count: %d\neNB0 RSSI %d dBm/RE (%d dB, %d dB)\neNB1 RSSI %d dBm/RE (%d dB, %d dB)\neNB2 RSSI %d dBm/RE (%d dB, %d dB)\nN0 %d dBm/RE, %f dBm/%dPRB (%d dB, %d dB)\n",
 		 phy_vars_ue->frame_rx,
 		 phy_vars_ue->PHY_measurements.rx_rssi_dBm[0],
 		 phy_vars_ue->PHY_measurements.rx_power_dB[0][0],
@@ -77,14 +77,15 @@ int dump_ue_stats(PHY_VARS_UE *phy_vars_ue, char* buffer, int length, runmode_t
 		 phy_vars_ue->PHY_measurements.rx_power_dB[2][0],
 		 phy_vars_ue->PHY_measurements.rx_power_dB[2][1],
 		 phy_vars_ue->PHY_measurements.n0_power_tot_dBm,
+		 phy_vars_ue->PHY_measurements.n0_power_tot_dBm+10*log10(12*phy_vars_ue->lte_frame_parms.N_RB_DL),
+		 phy_vars_ue->lte_frame_parms.N_RB_DL,
 		 phy_vars_ue->PHY_measurements.n0_power_dB[0],
 		 phy_vars_ue->PHY_measurements.n0_power_dB[1]);
 #ifdef EXMIMO
   len += sprintf(&buffer[len], "[UE PROC] RX Gain %d dB (LNA %d, vga %d dB)\n",phy_vars_ue->rx_total_gain_dB, openair0_cfg[0].rxg_mode[0],(int)openair0_cfg[0].rx_gain[0]);
 #endif
 #ifdef USRP
-  len += sprintf(&buffer[len], "[UE PROC] RX Gain %d (%f) dB\n",phy_vars_ue->rx_total_gain_dB,
-		 (double)phy_vars_ue->rx_total_gain_dB-USRP_GAIN_OFFSET);
+  len += sprintf(&buffer[len], "[UE PROC] RX Gain %d dB\n",phy_vars_ue->rx_total_gain_dB);
 #endif
 
   len += sprintf(&buffer[len], "[UE_PROC] Frequency offset %d Hz (%d)\n",phy_vars_ue->lte_ue_common_vars.freq_offset,openair_daq_vars.freq_offset);
@@ -446,7 +447,9 @@ int dump_ue_stats(PHY_VARS_UE *phy_vars_ue, char* buffer, int length, runmode_t
       RRC_status = mac_get_rrc_status(phy_vars_ue->Mod_id,0,0);
       len += sprintf(&buffer[len],"[UE PROC] RRC status = %d\n",RRC_status);
 #endif
-      len += sprintf(&buffer[len],"[UE PROC] RSRP[0] %d, RSSI %d, RSRQ[0] %d\n",phy_vars_ue->PHY_measurements.rsrp[0], phy_vars_ue->PHY_measurements.rssi, phy_vars_ue->PHY_measurements.rsrq[0]);
+      len += sprintf(&buffer[len],"[UE PROC] RSRP[0] %.2f dBm/RE, RSSI %.2f, RSRQ[0] %.2f\n",
+		     10*log10(phy_vars_ue->PHY_measurements.rsrp[0])-phy_vars_ue->rx_total_gain_dB, 
+		     10*log10(phy_vars_ue->PHY_measurements.rssi)-phy_vars_ue->rx_total_gain_dB, 10*log10(phy_vars_ue->PHY_measurements.rsrq[0]));
     
     len += sprintf(&buffer[len], "[UE PROC] Transmission Mode %d (mode1_flag %d)\n",phy_vars_ue->transmission_mode[eNB],phy_vars_ue->lte_frame_parms.mode1_flag);
     len += sprintf(&buffer[len], "[UE PROC] PBCH err conseq %d, PBCH error total %d, PBCH FER %d\n",

openair1/PHY/MODULATION/slot_fep.c

@@ -125,15 +125,29 @@ int slot_fep(PHY_VARS_UE *phy_vars_ue,
 	memcpy((short *)&ue_common_vars->rxdata[aa][frame_length_samples],
 	       (short *)&ue_common_vars->rxdata[aa][0],
 	       frame_parms->ofdm_symbol_size*sizeof(int));
-      start_meas(&phy_vars_ue->rx_dft_stats);
+
+      if ((rx_offset&3)!=0) {  // if input to dft is not 128-bit aligned, issue for size 6 and 15 PRBs
+	memcpy((void *)tmp_dft_in,
+	       (void *)&ue_common_vars->rxdata[aa][(rx_offset-nb_prefix_samples0) % frame_length_samples],
+	       frame_parms->ofdm_symbol_size*sizeof(int));
 #ifdef USRP
-      rescale((int16_t *)&ue_common_vars->rxdata[aa][(rx_offset-nb_prefix_samples0) % frame_length_samples],
-	      frame_parms->ofdm_symbol_size+nb_prefix_samples0);
+	rescale((int16_t *)tmp_dft_in,
+	        frame_parms->ofdm_symbol_size);
 #endif
-      dft((int16_t *)&ue_common_vars->rxdata[aa][(rx_offset) % frame_length_samples],
-	  (int16_t *)&ue_common_vars->rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1);
-      stop_meas(&phy_vars_ue->rx_dft_stats);
-      
+	dft((int16_t *)tmp_dft_in,
+	    (int16_t *)&ue_common_vars->rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1);
+      }
+      else {// use dft input from RX buffer directly 
+	start_meas(&phy_vars_ue->rx_dft_stats);
+#ifdef USRP
+	rescale((int16_t *)&ue_common_vars->rxdata[aa][(rx_offset-nb_prefix_samples0) % frame_length_samples],
+		frame_parms->ofdm_symbol_size+nb_prefix_samples0);
+#endif
+	dft((int16_t *)&ue_common_vars->rxdata[aa][(rx_offset) % frame_length_samples],
+	    (int16_t *)&ue_common_vars->rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1);
+	stop_meas(&phy_vars_ue->rx_dft_stats);
+	
+      }
     }
     else {
       rx_offset += (frame_parms->ofdm_symbol_size+nb_prefix_samples) +

openair2/RRC/LITE/rrc_UE.c

@@ -1976,7 +1976,7 @@ decode_BCCH_DLSCH_Message(
 #endif
   ) {
       rrc_ue_generate_RRCConnectionRequest(ue_mod_idP, frameP, 0);
-      LOG_I(RRC, "not sending connection request\n");
+      //      LOG_I(RRC, "not sending connection request\n");
 
       rrc_set_sub_state (ue_mod_idP, RRC_SUB_STATE_IDLE_CONNECTING);
   }

targets/ARCH/COMMON/common_lib.h

@@ -44,7 +44,7 @@ typedef struct openair0_device_t openair0_device;
 #define MAX_CARDS 1
 #endif
 
-#define USRP_GAIN_OFFSET (65.0)  // 82 calibrated for USRP B210 @ 2.6 GHz
+#define USRP_GAIN_OFFSET (86.0)  // 86 calibrated for USRP B210 @ 2.6 GHz to get equivalent RS EPRE in OAI to SMBV100 output
 
 typedef enum {
   max_gain=0,med_gain,byp_gain

targets/RT/USER/lte-softmodem.c

@@ -123,6 +123,9 @@ unsigned short config_frames[4] = {2,9,11,13};
 # include "create_tasks.h"
 # if defined(ENABLE_USE_MME)
 #   include "s1ap_eNB.h"
+#ifdef NAS_NETLINK
+#   include "SIMULATION/ETH_TRANSPORT/proto.h"
+#endif
 # endif
 #endif
 
@@ -2529,11 +2532,24 @@ int main(int argc, char **argv) {
 
       openair0_cfg[card].tx_gain[i] = tx_gain[0][i];
       openair0_cfg[card].rx_gain[i] = ((UE_flag==0) ? PHY_vars_eNB_g[0][0]->rx_total_gain_eNB_dB : 
-                                       PHY_vars_UE_g[0][0]->rx_total_gain_dB) - USRP_GAIN_OFFSET;  // calibrated for USRP B210 @ 2.6 GHz
+                                       PHY_vars_UE_g[0][0]->rx_total_gain_dB) - USRP_GAIN_OFFSET;  // calibrated for USRP B210 @ 2.6 GHz, 30.72 MS/s
+      switch(frame_parms[0]->N_RB_DL) {
+      case 6:
+	openair0_cfg[card].rx_gain[i] -= 6;
+	break;
+      case 25:
+	openair0_cfg[card].rx_gain[i] += 6;
+	break;
+      case 50:
+	openair0_cfg[card].rx_gain[i] += 8;
+	break;
+      default:
+	break;
+      }
       openair0_cfg[card].tx_freq[i] = (UE_flag==0) ? downlink_frequency[0][i] : downlink_frequency[0][i]+uplink_frequency_offset[0][i];
       openair0_cfg[card].rx_freq[i] = (UE_flag==0) ? downlink_frequency[0][i] + uplink_frequency_offset[0][i] : downlink_frequency[0][i];
-      printf("Setting tx_gain %f, rx_gain %f, tx_freq %f, rx_freq %f\n",
-	     openair0_cfg[card].tx_gain[i],
+      printf("Card %d, channel %d, Setting tx_gain %f, rx_gain %f, tx_freq %f, rx_freq %f\n",
+	     card,i, openair0_cfg[card].tx_gain[i],
 	     openair0_cfg[card].rx_gain[i],
 	     openair0_cfg[card].tx_freq[i],
 	     openair0_cfg[card].rx_freq[i]);
@@ -2812,6 +2828,12 @@ int main(int argc, char **argv) {
   // Sleep to allow all threads to setup
   sleep(1);
 
+#ifdef USE_MME
+  while (start_UE == 0) {
+    sleep(1);
+  }
+#endif
+
 #ifndef EXMIMO
 #ifndef USRP_DEBUG
   openair0.trx_start_func(&openair0);

targets/RT/USER/lte-ue.c

@@ -257,24 +257,42 @@ static void *UE_thread_synch(void *arg) {
     
 	openair0_cfg[card].rx_freq[i] = downlink_frequency[card][i];
 	openair0_cfg[card].tx_freq[i] = downlink_frequency[card][i]+uplink_frequency_offset[card][i];
+#ifdef USRP
 	openair0_cfg[card].rx_gain[i] = UE->rx_total_gain_dB-USRP_GAIN_OFFSET;  
+	switch(UE->lte_frame_parms.N_RB_DL) {
+	case 6:
+	  openair0_cfg[card].rx_gain[i] -= 12;
+	  break;
+	case 25:
+	  openair0_cfg[card].rx_gain[i] -= 6;
+	  break;
+	case 50:
+	  openair0_cfg[card].rx_gain[i] -= 3;
+	  break;
+	default:
+	  printf("Unknown number of RBs %d\n",UE->lte_frame_parms.N_RB_DL);
+	  break;
+	}
+	printf("UE synch: setting RX gain (%d,%d) to %d\n",card,i,openair0_cfg[card].rx_gain[i]);
+#endif
+      }
+#ifdef EXMIMO
+	openair0_config(&openair0_cfg[card],1);
+#endif
+      }
 #ifdef USRP
 #ifndef USRP_DEBUG
 	openair0_set_rx_frequencies(&openair0,&openair0_cfg[0]);
 	openair0_set_gains(&openair0,&openair0_cfg[0]);
 #endif
-#else
-	openair0_config(&openair0_cfg[0],1);
 #endif
+	LOG_D(PHY,"[SCHED][UE] Scanning band %d, freq %u\n",bands_to_scan.band_info[0].band, bands_to_scan.band_info[0].dl_min);
       }
-      }    
-    LOG_D(PHY,"[SCHED][UE] Scanning band %d, freq %u\n",bands_to_scan.band_info[0].band, bands_to_scan.band_info[0].dl_min);
-  }
   else {
     LOG_D(PHY,"[SCHED][UE] Check absolute frequency %u (oai_exit %d)\n",downlink_frequency[0][0],oai_exit);
 
     sync_mode=pbch;
-  }
+      }
 
   while (oai_exit==0) {
     
@@ -296,15 +314,15 @@ static void *UE_thread_synch(void *arg) {
     vcd_signal_dumper_dump_function_by_name(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SYNCH,1); 
     printf("Sync_mode %d\n",sync_mode);
     switch (sync_mode) {
-    case pss:
+      case pss:
 	
-
-
-      current_offset += 20000000; // increase by 20 MHz
-      if (current_offset > bands_to_scan.band_info[current_band].dl_max-bands_to_scan.band_info[current_band].dl_min) {
+	
+	
+	current_offset += 20000000; // increase by 20 MHz
+	if (current_offset > bands_to_scan.band_info[current_band].dl_max-bands_to_scan.band_info[current_band].dl_min) {
 	current_band++;
 	current_offset=0;
-      }
+	}
       if (current_band==bands_to_scan.nbands) {
 	current_band=0;
 	oai_exit=1; 
@@ -318,16 +336,36 @@ static void *UE_thread_synch(void *arg) {
 	  
 	  openair0_cfg[card].rx_freq[i] = downlink_frequency[card][i]+openair_daq_vars.freq_offset;
 	  openair0_cfg[card].tx_freq[i] = downlink_frequency[card][i]+uplink_frequency_offset[card][i]+openair_daq_vars.freq_offset;
+#ifdef USRP
 	  openair0_cfg[card].rx_gain[i] = UE->rx_total_gain_dB-USRP_GAIN_OFFSET;  // 65 calibrated for USRP B210 @ 2.6 GHz
+	  switch(UE->lte_frame_parms.N_RB_DL) {
+	  case 6:
+	    openair0_cfg[card].rx_gain[i] -= 12;
+	    break;
+	  case 25:
+	    openair0_cfg[card].rx_gain[i] -= 6;
+	    break;
+	  case 50:
+	    openair0_cfg[card].rx_gain[i] -= 3;
+	    break;
+	  default:
+	    printf("Unknown number of RBs %d\n",UE->lte_frame_parms.N_RB_DL);
+	    break;
+	  }
+	  printf("UE synch: setting RX gain (%d,%d) to %d\n",card,i,openair0_cfg[card].rx_gain[i]);
+#endif
+	
+      }
+#ifdef EXMIMO
+	  openair0_config(&openair0_cfg[card],1);	
+#endif
+    }	
 #ifdef USRP
 #ifndef USRP_DEBUG
-	  openair0_set_rx_frequencies(&openair0,&openair0_cfg[0]);
+      openair0_set_rx_frequencies(&openair0,&openair0_cfg[0]);
 	  //	openair0_set_gains(&openair0,&openair0_cfg[0]);
 #endif
 #endif
-	}
-      }	
-      
       break;
     case pbch:
       printf("Running initial sync\n");
@@ -384,6 +422,28 @@ static void *UE_thread_synch(void *arg) {
 	      openair0_cfg[card].rx_freq[i] = downlink_frequency[card][i]+openair_daq_vars.freq_offset;
 	      openair0_cfg[card].tx_freq[i] = downlink_frequency[card][i]+uplink_frequency_offset[card][i]+openair_daq_vars.freq_offset;
 	      openair0_cfg[card].rx_gain[i] = UE->rx_total_gain_dB-USRP_GAIN_OFFSET;  // 65 calibrated for USRP B210 @ 2.6 GHz
+#ifdef USRP
+	      switch(UE->lte_frame_parms.N_RB_DL) {
+	      case 6:
+		openair0_cfg[card].rx_gain[i] -= 12;
+		break;
+	      case 25:
+		openair0_cfg[card].rx_gain[i] -= 6;
+		break;
+	      case 50:
+		openair0_cfg[card].rx_gain[i] -= 3;
+		break;
+	      default:
+		printf("Unknown number of RBs %d\n",UE->lte_frame_parms.N_RB_DL);
+		break;
+	      }
+	      printf("UE synch: setting RX gain (%d,%d) to %d\n",card,i,openair0_cfg[card].rx_gain[i]);
+#endif
+	    }
+#ifdef EXMIMO
+	      openair0_config(&openair0_cfg[card],1);
+#endif
+	    }
 #ifdef USRP
 #ifndef USRP_DEBUG
 	      openair0_set_frequencies(&openair0,&openair0_cfg[0]);
@@ -391,16 +451,16 @@ static void *UE_thread_synch(void *arg) {
 #endif
 
 #else
-	      openair0_config(&openair0_cfg[card],1);
+
 #endif
-	    }
-	  }
+	    
+	  
 	    
 	  //	    openair0_dump_config(&openair0_cfg[0],UE_flag);
 	    
 	  //	    rt_sleep_ns(FRAME_PERIOD);
-	} // freq_offset
-      } // initial_sync=0
+	    } // freq_offset
+	    } // initial_sync=0
       break;
     case si:
     default:
@@ -496,8 +556,9 @@ static void *UE_thread_tx(void *arg) {
       }
     }
     
-    
-    if ((subframe_select(&UE->lte_frame_parms,UE->slot_tx>>1)==SF_UL)){
+
+    if ((subframe_select(&UE->lte_frame_parms,UE->slot_tx>>1)==SF_UL)||
+	(UE->lte_frame_parms.frame_type == FDD)){
       phy_procedures_UE_TX(UE,0,0,UE->mode,no_relay);
     }
     if ((subframe_select(&UE->lte_frame_parms,UE->slot_tx>>1)==SF_S) &&
@@ -890,6 +951,32 @@ void *UE_thread(void *arg) {
 	    exit_fun("nothing to add");
 	  }
 	}
+
+	if (pthread_mutex_lock(&UE->mutex_tx) != 0) {
+	  LOG_E(PHY,"[SCHED][UE] error locking mutex for UE TX thread\n");
+	  exit_fun("nothing to add");
+	}
+	else {
+
+	  if (tx_enabled == 1) {
+	    UE->instance_cnt_tx++;
+	    //printf("UE_thread: Unlocking UE mutex_rx\n");
+	    pthread_mutex_unlock(&UE->mutex_tx);
+	    if (UE->instance_cnt_tx == 0) {
+	      if (pthread_cond_signal(&UE->cond_tx) != 0) {
+		LOG_E(PHY,"[SCHED][UE] ERROR pthread_cond_signal for UE TX thread\n");
+		exit_fun("nothing to add");
+	      }
+	      else {
+		//	      printf("UE_thread: cond_signal for RX ok (%p) @ %llu\n",(void*)&UE->cond_rx,rt_get_time_ns()-T0);
+	      }
+	    }
+	    else {
+	      LOG_E(PHY,"[SCHED][UE] UE TX thread busy!!\n");
+	      exit_fun("nothing to add");
+	    }
+	  }
+	}
       }
     }
     else {  // we are not yet synchronized
@@ -946,6 +1033,7 @@ void *UE_thread(void *arg) {
 	    rt_sleep_ns(10000000);
 #endif
 	    UE->rx_offset=0;
+	    tx_enabled=1;
 	  }
 	  else if ((UE->rx_offset < RX_OFF_MIN)&&(start_rx_stream==1) && (rx_correction_timer == 0)) {
 	    rx_off_diff = -UE->rx_offset + RX_OFF_MIN;