initial rfsimulator commit

cmake_targets/build_oai

@@ -250,7 +250,7 @@ function main() {
        -w | --hardware)
             HW="$2" #"${i#*=}"
             # Use OAI_USRP  as the key word USRP is used inside UHD driver
-	    if [ "$HW" != "BLADERF" -a  "$HW" != "USRP" -a "$HW" != "LMSSDR" -a  "$HW" != "None" -a  "$HW" != "EXMIMO" -a  "$HW" != "ADRV9371_ZC706"  ] ; then 
+	    if [ "$HW" != "BLADERF" -a  "$HW" != "USRP" -a "$HW" != "LMSSDR" -a  "$HW" != "None" -a  "$HW" != "EXMIMO" -a  "$HW" != "ADRV9371_ZC706"  -a  "$HW" != "SIMU" ] ; then 
 		echo_fatal "Unknown HW type $HW will exit..."		
 	    else
 		if [ "$HW" == "USRP" ] ; then 
@@ -265,6 +265,9 @@ function main() {
 		if [ "$HW" == "LMSSDR" ] ; then 
 		    HW="OAI_LMSSDR"
 		fi 
+		if [ "$HW" == "SIMU" ] ; then
+                    HW="OAI_SIMU"
+                fi
 		echo_info "Setting hardware to: $HW"
 	    fi
             shift 2;;

cmake_targets/tools/make_asn1c_includes.sh

+#!/bin/bash
+GENERATED_FULL_DIR=$1
+shift
+ASN1_SOURCE_DIR=$1
+shift
+export ASN1C_PREFIX=$1 
+shift
+options=$*
+done_flag="$GENERATED_FULL_DIR"/done
+if [ "$done_flag" -ot $ASN1_SOURCE_DIR ] ; then 
+   rm -f "$GENERATED_FULL_DIR"/${ASN1C_PREFIX}*.c "$GENERATED_FULL_DIR"/${ASN1C_PREFIX}*.h
+   mkdir -p "$GENERATED_FULL_DIR"
+   asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example $options -D $GENERATED_FULL_DIR $ASN1_SOURCE_DIR |& egrep -v "^Copied|^Compiled" | sort -u
+fi
+touch $done_flag

common/utils/backtrace.h

@@ -23,9 +23,16 @@
 
 #ifndef BACKTRACE_H_
 #define BACKTRACE_H_
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 void display_backtrace(void);
 
 void backtrace_handle_signal(siginfo_t *info);
+#ifdef __cplusplus
+}
+#endif
+
 
 #endif /* BACKTRACE_H_ */

openair1/PHY/TOOLS/lte_phy_scope.c

@@ -151,12 +151,12 @@ FD_lte_phy_scope_enb *create_lte_phy_scope_enb( void )
 }
 
 void phy_scope_eNB(FD_lte_phy_scope_enb *form,
-                   PHY_VARS_eNB *phy_vars_enb,
+                   PHY_VARS_gNB *phy_vars_enb,
                    int UE_id)
 {
   int eNB_id = 0;
   int i,i2,arx,atx,ind,k;
-  LTE_DL_FRAME_PARMS *frame_parms = &phy_vars_enb->frame_parms;
+  NR_DL_FRAME_PARMS *frame_parms = &phy_vars_enb->frame_parms;
   int nsymb_ce = 12*frame_parms->N_RB_UL*frame_parms->symbols_per_tti;
   uint8_t nb_antennas_rx = frame_parms->nb_antennas_rx;
   uint8_t nb_antennas_tx = 1; // frame_parms->nb_antennas_tx; // in LTE Rel. 8 and 9 only a single transmit antenna is assumed at the UE
@@ -178,7 +178,7 @@ void phy_scope_eNB(FD_lte_phy_scope_enb *form,
   float time[FRAME_LENGTH_COMPLEX_SAMPLES];
   float time2[2048];
   float freq[nsymb_ce*nb_antennas_rx*nb_antennas_tx];
-  int frame = phy_vars_enb->proc.proc_rxtx[0].frame_tx;
+  int frame = phy_vars_enb->proc.L1_proc_tx.frame_tx;
   uint32_t total_dlsch_bitrate = phy_vars_enb->total_dlsch_bitrate;
   int coded_bits_per_codeword = 0;
   uint8_t harq_pid; // in TDD config 3 it is sf-2, i.e., can be 0,1,2

openair1/PHY/TOOLS/lte_phy_scope.h

@@ -25,7 +25,7 @@
 #define FD_lte_scope_h_
 
 #include <forms.h>
-#include "PHY/defs_eNB.h"
+#include "PHY/defs_gNB.h"
 #include "PHY/defs_UE.h"
 #include "PHY/impl_defs_top.h"
 
@@ -66,7 +66,7 @@ FD_lte_phy_scope_enb * create_lte_phy_scope_enb( void );
 FD_lte_phy_scope_ue * create_lte_phy_scope_ue( void );
 
 void phy_scope_eNB(FD_lte_phy_scope_enb *form,
-                   PHY_VARS_eNB *phy_vars_enb,
+                   PHY_VARS_gNB *phy_vars_gnb,
                    int UE_id);
 
 void phy_scope_UE(FD_lte_phy_scope_ue *form,

openair1/PHY/defs_RU.h

@@ -399,7 +399,7 @@ typedef struct RU_t_s{
   /// function pointer to release function for radio interface
   int                  (*stop_rf)(struct RU_t_s *ru);
   /// function pointer to initialization function for radio interface
-  int                  (*start_if)(struct RU_t_s *ru,struct PHY_VARS_eNB_s *eNB);
+  int                  (*start_if)(struct RU_t_s *ru,struct PHY_VARS_gNB_s *gNB);
   /// function pointer to RX front-end processing routine (DFTs/prefix removal or NULL)
   void                 (*feprx)(struct RU_t_s *ru);
   /// function pointer to TX front-end processing routine (IDFTs and prefix removal or NULL)

openair1/PHY/defs_common.h

@@ -78,8 +78,8 @@
 
 #include "defs_RU.h"
 
-#define RX_NB_TH_MAX 2
-#define RX_NB_TH 2
+#define RX_NB_TH_MAX 1
+#define RX_NB_TH 1
 
 #define LTE_SLOTS_PER_SUBFRAME 2
 

openair1/SCHED_NR/phy_procedures_nr_common.c

@@ -36,4 +36,6 @@ nr_subframe_t nr_slot_select(nfapi_nr_config_request_t *cfg,unsigned char slot)
 {
   if (cfg->subframe_config.duplex_mode.value == FDD)
     return(SF_DL);
+  LOG_E(PHY,"Not developped TDD mode\n");
+  return -1;
 }

openair1/SCHED_UE/phy_procedures_lte_ue.c

@@ -2885,10 +2885,10 @@ int ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint
 	      {
                 ue->dlsch[th_id][eNB_id][0]->g_pucch += delta_pucch;
 	      }
-            LOG_D(PHY,"update TPC for PUCCH %d.%d / pid %d delta_PUCCH %d g_pucch %d %d \n",frame_rx, subframe_rx,ue->dlsch[ue->current_thread_id[subframe_rx]][eNB_id][0]->current_harq_pid,
+            LOG_D(PHY,"update TPC for PUCCH %d.%d / pid %d delta_PUCCH %d g_pucch %d\n",
+			    frame_rx, subframe_rx,ue->dlsch[ue->current_thread_id[subframe_rx]][eNB_id][0]->current_harq_pid,
 		  delta_pucch,
-		  ue->dlsch[0][eNB_id][0]->g_pucch,
-		  ue->dlsch[1][eNB_id][0]->g_pucch
+		  ue->dlsch[0][eNB_id][0]->g_pucch
 		  //ue->dlsch[2][eNB_id][0]->g_pucch
 		  );
           }

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler.c

@@ -58,6 +58,7 @@
 #endif
 
 #include "assertions.h"
+#include <openair1/PHY/LTE_TRANSPORT/transport_proto.h>
 
 #define ENABLE_MAC_PAYLOAD_DEBUG
 #define DEBUG_eNB_SCHEDULER 1
@@ -382,7 +383,7 @@ void gNB_dlsch_ulsch_scheduler(module_id_t module_idP,
           }
 
           for (int ii=0; ii<MAX_MOBILES_PER_GNB; ii++) {
-            LTE_eNB_DLSCH_t *dlsch = RC.gNB[module_idP][CC_id]->dlsch[ii][0];
+            NR_gNB_DLSCH_t *dlsch = RC.gNB[module_idP][CC_id]->dlsch[ii][0];
             if((dlsch != NULL) && (dlsch->rnti == rnti)){
               LOG_I(MAC, "clean_eNb_dlsch UE %x \n", rnti);
               clean_eNb_dlsch(dlsch);

targets/ARCH/COMMON/common_lib.c

@@ -34,40 +34,42 @@
 #include <dlfcn.h>
 #include <errno.h>
 #include <string.h>
+#include <stdlib.h>
 
 #include "common_lib.h"
 #include "common/utils/load_module_shlib.h"
+#include <common/utils/LOG/log.h>
 
 int set_device(openair0_device *device) {
 
   switch (device->type) {
     
   case EXMIMO_DEV:
-    printf("[%s] has loaded EXPRESS MIMO device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+    LOG_I(HW,"[%s] has loaded EXPRESS MIMO device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
     break;
   case USRP_B200_DEV:
-    printf("[%s] has loaded USRP B200 device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
+    LOG_I(HW,"[%s] has loaded USRP B200 device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
     break;
-case USRP_X300_DEV:
-    printf("[%s] has loaded USRP X300 device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
+  case USRP_X300_DEV:
+    LOG_I(HW,"[%s] has loaded USRP X300 device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
     break;
   case BLADERF_DEV:
-    printf("[%s] has loaded BLADERF device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
+    LOG_I(HW,"[%s] has loaded BLADERF device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
     break;
   case LMSSDR_DEV:
-    printf("[%s] has loaded LMSSDR device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
+    LOG_I(HW,"[%s] has loaded LMSSDR device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
     break;
   case NONE_DEV:
-    printf("[%s] has not loaded a HW device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+    LOG_W(HW,"[%s] has not loaded a HW device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
     break;    
   case ADRV9371_ZC706_DEV:
-    printf("[%s] has loaded ADRV9371_ZC706 device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+    LOG_I(HW,"[%s] has loaded ADRV9371_ZC706 device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
     break;
   case UEDv2_DEV:
-    printf("[%s] has loaded UEDv2 device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+    LOG_I(HW,"[%s] has loaded UEDv2 device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
     break;
   default:
-    printf("[%s] invalid HW device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
+    LOG_E(HW,"[%s] invalid HW device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
     return -1;
   }
   return 0;
@@ -78,15 +80,15 @@ int set_transport(openair0_device *device) {
   switch (device->transp_type) {
     
   case ETHERNET_TP:
-    printf("[%s] has loaded ETHERNET trasport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+    LOG_I(HW,"[%s] has loaded ETHERNET trasport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
     return 0;     
     break;
   case NONE_TP:
-    printf("[%s] has not loaded a transport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+    LOG_W(HW,"[%s] has not loaded a transport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
     return 0; 
     break;    
   default:
-    printf("[%s] invalid transport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
+    LOG_E(HW,"[%s] invalid transport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
     return -1;
     break;
   }
@@ -100,6 +102,9 @@ int load_lib(openair0_device *device, openair0_config_t *openair0_cfg, eth_param
   int ret=0;
   char *libname;
   if (flag == RAU_LOCAL_RADIO_HEAD) {
+	  if (getenv("RFSIMULATOR") != NULL) 
+     	  libname="rfsimulator";
+	  else 
       libname=OAI_RF_LIBNAME;
       shlib_fdesc[0].fname="device_init";
     } else {
@@ -108,7 +113,7 @@ int load_lib(openair0_device *device, openair0_config_t *openair0_cfg, eth_param
     } 
   ret=load_module_shlib(libname,shlib_fdesc,1,NULL);
   if (ret < 0) {
-       fprintf(stderr,"Library %s couldn't be loaded\n",libname);
+       LOG_E(HW,"Library %s couldn't be loaded\n",libname);
   } else {
        ret=((devfunc_t)shlib_fdesc[0].fptr)(device,openair0_cfg,cfg);
   }    
@@ -124,7 +129,7 @@ int openair0_device_load(openair0_device *device, openair0_config_t *openair0_cf
 
   if ( rc >= 0) {       
 	if ( set_device(device) < 0) {
-      fprintf(stderr, "%s %d:Unsupported radio head\n",__FILE__, __LINE__);
+      LOG_E(HW,"Unsupported radio head\n");
       return -1;		   
     }   
   }
@@ -136,7 +141,7 @@ int openair0_transport_load(openair0_device *device, openair0_config_t *openair0
   rc=load_lib(device, openair0_cfg, eth_params, RAU_REMOTE_RADIO_HEAD);
   if ( rc >= 0) {       
     if ( set_transport(device) < 0) {
-      fprintf(stderr, "%s %d:Unsupported transport protocol\n",__FILE__, __LINE__);
+      LOG_E(HW,"Unsupported transport protocol\n");
       return -1;		   
       }   
   }

targets/ARCH/rfsimulator/README.md

+#General
+This is a RF simulator that allows to test OAI without a RF board.
+It replaces a actual RF board driver.
+
+As much as possible, it works like a RF board, but not in realtime: it can run faster than realtime if there is enough CPU or slower (it is CPU bound instead of real time RF sampling bound)
+
+#build 
+You can build it the same way, and together with actual RF driver
+
+Example:
+```bash
+./build_oai --ue-nas-use-tun --UE --eNB -w SIMU
+```
+It is also possible to build actual RF and use choose on each run:
+```bash
+./build_oai --ue-nas-use-tun --UE --eNB -w USRP --rfsimulator
+```
+Will build both the eNB (lte-softmodem) and the UE (lte-uesoftmodem)
+We recommend to use the option --ue-nas-use-tun that is much simpler to use than the OAI kernel driver.
+
+#usage
+Setting the env variable RFSIMULATOR enables the RF board simulator
+It should the set to "enb" in the eNB
+
+For the UE, it should be set to the IP address of the eNB
+example: 
+```bash
+sudo RFSIMULATOR=192.168.2.200 ./lte-uesoftmodem -C 2685000000 -r 50 
+```
+Except this, the UE and the eNB can be used as it the RF is real
+
+If you reach 'RA not active' on UE, be careful to generate a valid SIM
+```bash
+$OPENAIR_DIR/targets/bin/conf2uedata -c $OPENAIR_DIR/openair3/NAS/TOOLS/ue_eurecom_test_sfr.conf -o .
+```
+#Caveacts
+Still issues in power control: txgain, rxgain are not used
+
+no S1 mode is currently broken, so we were not able to test the simulator in noS1 mode

targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.106PRB.usrpn300.conf

@@ -282,7 +282,7 @@ NETWORK_CONTROLLER :
      {
        global_log_level                      ="info";
        global_log_verbosity                  ="medium";
-       hw_log_level                          ="info";
+       hw_log_level                          ="debug";
        hw_log_verbosity                      ="medium";
        phy_log_level                         ="info";
        phy_log_verbosity                     ="medium";

targets/RT/USER/nr-ue.c

@@ -630,7 +630,6 @@ static void *UE_thread_rxn_txnp4(void *arg) {
     struct nr_rxtx_thread_data *rtd = arg;
     UE_nr_rxtx_proc_t *proc = rtd->proc;
     PHY_VARS_NR_UE    *UE   = rtd->UE;
-    int ret;
 
     //proc->counter_decoder = 0;
     proc->instance_cnt_rxtx=-1;
@@ -782,7 +781,6 @@ void *UE_thread(void *arg) {
 
     PHY_VARS_NR_UE *UE = (PHY_VARS_NR_UE *) arg;
     //  int tx_enabled = 0;
-    int dummy_rx[UE->frame_parms.nb_antennas_rx][UE->frame_parms.samples_per_subframe] __attribute__((aligned(32)));
     openair0_timestamp timestamp;
     void* rxp[NB_ANTENNAS_RX], *txp[NB_ANTENNAS_TX];
     int start_rx_stream = 0;
@@ -834,45 +832,67 @@ void *UE_thread(void *arg) {
 
             if (instance_cnt_synch < 0) {  // we can invoke the synch
                 // grab 10 ms of signal and wakeup synch thread
-                for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
-                    rxp[i] = (void*)&UE->common_vars.rxdata[i][0];
-
-                if (UE->mode != loop_through_memory)
-                    AssertFatal( UE->frame_parms.samples_per_subframe*10==
-                                 UE->rfdevice.trx_read_func(&UE->rfdevice,
-                                                            &timestamp,
-                                                            rxp,
-                                                            UE->frame_parms.samples_per_subframe*10,
-                                                            UE->frame_parms.nb_antennas_rx), "error reading samples");
-
-		AssertFatal ( 0== pthread_mutex_lock(&UE->proc.mutex_synch), "");
-                instance_cnt_synch = ++UE->proc.instance_cnt_synch;
-                if (instance_cnt_synch == 0) {
-                    AssertFatal( 0 == pthread_cond_signal(&UE->proc.cond_synch), "");
-                } else {
-                    LOG_E( PHY, "[SCHED][UE] UE sync thread busy!!\n" );
-                    exit_fun("nothing to add");
-                }
-		AssertFatal ( 0== pthread_mutex_unlock(&UE->proc.mutex_synch), "");
-            } else {
-#if OAISIM
-              (void)dummy_rx; /* avoid gcc warnings */
-              usleep(500);
-#else
-                // grab 10 ms of signal into dummy buffer
-                if (UE->mode != loop_through_memory) {
-                    for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
-                        rxp[i] = (void*)&dummy_rx[i][0];
-                    for (int sf=0; sf<NR_NUMBER_OF_SUBFRAMES_PER_FRAME; sf++)
-                        //	    printf("Reading dummy sf %d\n",sf);
-		      AssertFatal(UE->frame_parms.samples_per_subframe==
-				 UE->rfdevice.trx_read_func(&UE->rfdevice,
-							    &timestamp,
-							    rxp,
-							    UE->frame_parms.samples_per_subframe,
-							    UE->frame_parms.nb_antennas_rx), "error reading samples");
-                }
-#endif
+	if (UE->mode != loop_through_memory) {
+	  void *dummy_tx[UE->frame_parms.nb_antennas_tx];
+	  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+	    dummy_tx[i]=malloc16_clear(UE->frame_parms.samples_per_subframe*4);
+	  for(int x=0; x<10; x++) {
+	    for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
+	      rxp[i] = ((void*)&UE->common_vars.rxdata[i][0]) + 4*x*UE->frame_parms.samples_per_subframe;
+	    AssertFatal( UE->frame_parms.samples_per_subframe ==
+			 UE->rfdevice.trx_read_func(&UE->rfdevice,
+						    &timestamp,
+						    rxp,
+						    UE->frame_parms.samples_per_subframe,
+						    UE->frame_parms.nb_antennas_rx), "");
+	    AssertFatal( UE->frame_parms.samples_per_subframe ==
+			 UE->rfdevice.trx_write_func(&UE->rfdevice,
+						     timestamp+(2*UE->frame_parms.samples_per_subframe) -
+						     openair0_cfg[0].tx_sample_advance,
+						     dummy_tx,
+						     UE->frame_parms.samples_per_subframe,
+						     UE->frame_parms.nb_antennas_tx,
+						     1),"");
+	  }
+	  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+	    free(dummy_tx[i]);
+	}
+	AssertFatal( 0 == pthread_mutex_lock(&UE->proc.mutex_synch), "");
+	AssertFatal( 0 == ++UE->proc.instance_cnt_synch, "[SCHED][UE] UE sync thread busy!!\n" );
+        AssertFatal( 0 == pthread_cond_signal(&UE->proc.cond_synch), "");
+	AssertFatal( 0 == pthread_mutex_unlock(&UE->proc.mutex_synch), "");
+      } else {
+	// grab 10 ms of signal into dummy buffer to wait result of sync detection
+	if (UE->mode != loop_through_memory) {
+	  void *dummy_tx[UE->frame_parms.nb_antennas_tx];
+	  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+	    dummy_tx[i]=malloc16_clear(UE->frame_parms.samples_per_subframe*4);
+	  void *dummy_rx[UE->frame_parms.nb_antennas_rx];
+	  for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
+	    dummy_rx[i]=malloc16(UE->frame_parms.samples_per_subframe*4);
+	  for (int sf=0; sf<NR_NUMBER_OF_SUBFRAMES_PER_FRAME; sf++) {
+	    //	    printf("Reading dummy sf %d\n",sf);
+	    UE->rfdevice.trx_read_func(&UE->rfdevice,
+				       &timestamp,
+				       dummy_rx,
+				       UE->frame_parms.samples_per_subframe,
+				       UE->frame_parms.nb_antennas_rx);
+	  AssertFatal( UE->frame_parms.samples_per_subframe ==
+		       UE->rfdevice.trx_write_func(&UE->rfdevice,
+						   timestamp+(2*UE->frame_parms.samples_per_subframe) -
+						   openair0_cfg[0].tx_sample_advance,
+						   dummy_tx,
+						   UE->frame_parms.samples_per_subframe,
+						   UE->frame_parms.nb_antennas_tx,
+						   1),"");
+	   usleep(9000); // this sleep improves in the case of simulated RF and doesn't harm with true radio
+	  
+	  }
+	  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+	    free(dummy_tx[i]);
+	  for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
+	    free(dummy_rx[i]);
+	}
             }
 
         } // UE->is_synchronized==0
@@ -882,12 +902,28 @@ void *UE_thread(void *arg) {
                 if (UE->mode != loop_through_memory) {
                     if (UE->no_timing_correction==0) {
                         LOG_I(PHY,"Resynchronizing RX by %d samples (mode = %d)\n",UE->rx_offset,UE->mode);
-                        AssertFatal(UE->rx_offset ==
-                                    UE->rfdevice.trx_read_func(&UE->rfdevice,
-                                                               &timestamp,
-                                                               (void**)UE->common_vars.rxdata,
-                                                               UE->rx_offset,
-                                                               UE->frame_parms.nb_antennas_rx),"");
+		    void *dummy_tx[UE->frame_parms.nb_antennas_tx];
+		    for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+		      dummy_tx[i]=malloc16_clear(UE->frame_parms.samples_per_subframe*4);
+		    for ( int size=UE->rx_offset ; size > 0 ; size -= UE->frame_parms.samples_per_subframe ) { 
+		      int unitTransfer=size>UE->frame_parms.samples_per_subframe ? UE->frame_parms.samples_per_subframe : size ;
+		      AssertFatal(unitTransfer ==
+				  UE->rfdevice.trx_read_func(&UE->rfdevice,
+							     &timestamp,
+							     (void**)UE->common_vars.rxdata,
+							     unitTransfer,
+							     UE->frame_parms.nb_antennas_rx),"");
+		      AssertFatal( unitTransfer == 
+				   UE->rfdevice.trx_write_func(&UE->rfdevice,
+							       timestamp+(2*UE->frame_parms.samples_per_subframe) -
+							       openair0_cfg[0].tx_sample_advance,
+							       dummy_tx,
+							       unitTransfer,
+							       UE->frame_parms.nb_antennas_tx,
+							       1),"");
+		    }
+		    for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+		      free(dummy_tx[i]);
                     }
                     UE->rx_offset=0;
                     UE->time_sync_cell=0;
@@ -962,6 +998,7 @@ void *UE_thread(void *arg) {
                             UE->rx_offset_diff = 1;
 
                         LOG_D(PHY,"AbsSubframe %d.%d TTI SET rx_off_diff to %d rx_offset %d \n",proc->frame_rx,subframe_nr,UE->rx_offset_diff,UE->rx_offset);
+			
                         readBlockSize=UE->frame_parms.samples_per_subframe -
                                       UE->frame_parms.ofdm_symbol_size -
                                       UE->frame_parms.nb_prefix_samples0 -
@@ -1051,6 +1088,14 @@ void *UE_thread(void *arg) {
 #ifdef SAIF_ENABLED
 						g_ue_rx_thread_busy++;
 #endif
+	              if ( getenv("RFSIMULATOR") != NULL ) {
+		         do {
+			    AssertFatal (pthread_mutex_unlock(&proc->mutex_rxtx) == 0, "");
+			    usleep(100);
+			    AssertFatal (pthread_mutex_lock(&proc->mutex_rxtx) == 0, "");
+			 } while ( proc->instance_cnt_rxtx >= 0);
+
+		      } else
                       LOG_E( PHY, "[SCHED][UE %d] !! UE RX thread busy (IC %d)!!\n", UE->Mod_id, proc->instance_cnt_rxtx);
                       if (proc->instance_cnt_rxtx > 4)
                       {

targets/RT/USER/nr-uesoftmodem.c

@@ -984,23 +984,16 @@ int main( int argc, char **argv ) {
     for (uint8_t i=0; i<RX_NB_TH_MAX; i++) {
       //UE[CC_id]->pdcch_vars[i][0]->agregationLevel = agregation_Level;
       //UE[CC_id]->pdcch_vars[i][0]->dciFormat     = dci_Format;
-    }
     
     /*compute_prach_seq(&UE[CC_id]->frame_parms.prach_config_common,
       UE[CC_id]->frame_parms.frame_type,
       UE[CC_id]->X_u);*/
     
     if (UE[CC_id]->mac_enabled == 1)
-      {
-	UE[CC_id]->pdcch_vars[0][0]->crnti = 0x1234;
-	UE[CC_id]->pdcch_vars[1][0]->crnti = 0x1234;
-      }
+	UE[CC_id]->pdcch_vars[i][0]->crnti = 0x1234;
     else
-      {
-	UE[CC_id]->pdcch_vars[0][0]->crnti = 0x1235;
-	UE[CC_id]->pdcch_vars[1][0]->crnti = 0x1235;
-      }
-    
+	UE[CC_id]->pdcch_vars[i][0]->crnti = 0x1235;
+    }
     
     UE[CC_id]->rx_total_gain_dB =  (int)rx_gain[CC_id][0] + rx_gain_off;
     UE[CC_id]->tx_power_max_dBm = tx_max_power[CC_id];