Remove --emulate-rf option and corresponding code

With the RFemulator, there is no need for a dedicated --emulate-rf
option anymore. For all uses of --emulate-rf, RFemulator should be used
instead.

common/config/DOC/config/rtusage.md

@@ -55,7 +55,6 @@ To get help on supported parameters you can use specific options:
     --ulsch-max-errors: set the eNodeB max ULSCH erros
     --phy-test: test UE phy layer, mac disabled
     --usim-test: use XOR autentication algo in case of test usim mode
-    --emulate-rf: Emulated RF enabled(disable by defult)
     --clock: tells hardware to use a clock reference (0:internal, 1:external, 2:gpsdo)
     --wait-for-sync: Help string not specified
     -C: Set the downlink frequency for all component carriers

executables/lte-ru.c

@@ -531,44 +531,6 @@ volatile late_control_e late_control=STATE_BURST_NORMAL;
 
 /* add fail safe for late command end */
 
-static void *emulatedRF_thread(void *param) {
-  RU_proc_t *proc = (RU_proc_t *) param;
-  int microsec = 500; // length of time to sleep, in miliseconds
-  int numerology = 0 ;
-  struct timespec req = {0};
-  req.tv_sec = 0;
-  req.tv_nsec = (numerology>0)? ((microsec * 1000L)/numerology):(microsec * 1000L)*2;
-  cpu_set_t cpuset;
-  CPU_ZERO(&cpuset);
-  CPU_SET(1,&cpuset);
-  pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
-  int policy;
-  int ret;
-  struct sched_param sparam;
-  memset(&sparam, 0, sizeof(sparam));
-  sparam.sched_priority = sched_get_priority_max(SCHED_FIFO);
-  policy = SCHED_FIFO ;
-  pthread_setschedparam(pthread_self(), policy, &sparam);
-  wait_sync("emulatedRF_thread");
-
-  while(!oai_exit) {
-    nanosleep(&req, (struct timespec *)NULL);
-
-    if(proc->emulate_rf_busy ) {
-      LOG_E(PHY,"rf being delayed in emulated RF\n");
-    }
-
-    proc->emulate_rf_busy = 1;
-    AssertFatal((ret=pthread_mutex_lock(&proc->mutex_emulateRF))==0,"mutex_lock returns %d\n",ret);
-    ++proc->instance_cnt_emulateRF;
-    pthread_cond_signal(&proc->cond_emulateRF);
-    AssertFatal((ret=pthread_mutex_unlock(&proc->mutex_emulateRF))==0,"mutex_unlock returns %d\n",ret);
-  }
-
-  return 0;
-}
-
-
 void rx_rf(RU_t *ru,
            int *frame,
            int *subframe) {
@@ -586,17 +548,7 @@ void rx_rf(RU_t *ru,
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, 1 );
   old_ts = proc->timestamp_rx;
 
-  if(ru->emulate_rf) {
+  rxs = ru->rfdevice.trx_read_func(&ru->rfdevice, &ts, rxp, fp->samples_per_tti, ru->nb_rx);
-    wait_on_condition(&proc->mutex_emulateRF,&proc->cond_emulateRF,&proc->instance_cnt_emulateRF,"emulatedRF_thread");
-    release_thread(&proc->mutex_emulateRF,&proc->instance_cnt_emulateRF,"emulatedRF_thread");
-    rxs = fp->samples_per_tti;
-  } else {
-    rxs = ru->rfdevice.trx_read_func(&ru->rfdevice,
-                                     &ts,
-                                     rxp,
-                                     fp->samples_per_tti,
-                                     ru->nb_rx);
-  }
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, 0 );
   ru->south_in_cnt++;
@@ -613,11 +565,7 @@ void rx_rf(RU_t *ru,
     resynch=1;
   }
 
-  if(get_softmodem_params()->emulate_rf) {
+  proc->timestamp_rx = ts-ru->ts_offset;
-    proc->timestamp_rx = old_ts + fp->samples_per_tti;
-  } else {
-    proc->timestamp_rx = ts-ru->ts_offset;
-  }
 
   //  AssertFatal(rxs == fp->samples_per_tti,
   //        "rx_rf: Asked for %d samples, got %d from SDR\n",fp->samples_per_tti,rxs);
@@ -1229,7 +1177,6 @@ void wakeup_L1s(RU_t *ru) {
   //      pthread_mutex_unlock(&proc->mutex_RU);
   //      LOG_D(PHY,"wakeup eNB top for for subframe %d\n", ru->proc.tti_rx);
   //      ru->eNB_top(eNB_list[0],ru->proc.frame_rx,ru->proc.tti_rx,string);
-  ru->proc.emulate_rf_busy = 0;
 }
 
 
@@ -1497,7 +1444,6 @@ static void *ru_thread_tx( void *param ) {
   L1_rxtx_proc_t *L1_proc;
   cpu_set_t cpuset;
   CPU_ZERO(&cpuset);
-  char filename[256];
   thread_top_init("ru_thread_tx",1,400000,500000,500000);
   //CPU_SET(5, &cpuset);
   //pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
@@ -1530,24 +1476,12 @@ static void *ru_thread_tx( void *param ) {
     // do OFDM if needed
     if ((ru->fh_north_asynch_in == NULL) && (ru->feptx_ofdm)) ru->feptx_ofdm(ru,frame_tx,tti_tx);
 
-    if(!(ru->emulate_rf)) { //if(!emulate_rf){
+    // do outgoing fronthaul (south) if needed
-      // do outgoing fronthaul (south) if needed
+    if ((ru->fh_north_asynch_in == NULL) && (ru->fh_south_out))
-      if ((ru->fh_north_asynch_in == NULL) && (ru->fh_south_out)) ru->fh_south_out(ru,frame_tx,tti_tx,timestamp_tx);
+      ru->fh_south_out(ru, frame_tx, tti_tx, timestamp_tx);
 
-      if (ru->fh_north_out) ru->fh_north_out(ru);
+    if (ru->fh_north_out)
-    } else {
+      ru->fh_north_out(ru);
-      for (int i=0; i<ru->nb_tx; i++) {
-        if(frame_tx == 2) {
-          sprintf(filename,"txdataF%d_frame%d_sf%d.m",i,frame_tx,tti_tx);
-          LOG_M(filename,"txdataF_frame",ru->common.txdataF_BF[i],fp->symbols_per_tti*fp->ofdm_symbol_size, 1, 1);
-        }
-
-        if(frame_tx == 2 && tti_tx==0) {
-          sprintf(filename,"txdata%d_frame%d.m",i,frame_tx);
-          LOG_M(filename,"txdata_frame",ru->common.txdata[i],fp->samples_per_tti*10, 1, 1);
-        }
-      }
-    }
 
     LOG_D(PHY,"ru_thread_tx: releasing RU TX in %d.%d\n", frame_tx, tti_tx);
     release_thread(&proc->mutex_eNBs,&proc->instance_cnt_eNBs,"ru_thread_tx");
@@ -1612,7 +1546,6 @@ static void *ru_thread( void *param ) {
   int ret;
   cpu_set_t cpuset;
   CPU_ZERO(&cpuset);
-  char filename[256];
   // set default return value
 #if defined(PRE_SCD_THREAD)
   dlsch_ue_select_tbl_in_use = 1;
@@ -1625,21 +1558,7 @@ static void *ru_thread( void *param ) {
   LOG_I(PHY,"thread ru created id=%ld\n", syscall(__NR_gettid));
   LOG_I(PHY,"Starting RU %d (%s,%s),\n", ru->idx, NB_functions[ru->function], NB_timing[ru->if_timing]);
 
-  if(get_softmodem_params()->emulate_rf) {
+  if (ru->has_ctrl_prt == 0) {
-    phy_init_RU(ru);
-
-    if (setup_RU_buffers(ru)!=0) {
-      LOG_I(PHY,"Exiting, cannot initialize RU Buffers\n");
-      exit(-1);
-    }
-
-    LOG_I(PHY, "Signaling main thread that RU %d is ready\n",ru->idx);
-    AssertFatal((ret=pthread_mutex_lock(ru->ru_mutex))==0,"mutex_lock returns %d\n",ret);
-    *ru->ru_mask &= ~(1<<ru->idx);
-    pthread_cond_signal(ru->ru_cond);
-    AssertFatal((ret=pthread_mutex_unlock(ru->ru_mutex))==0,"mutex_unlock returns %d\n",ret);
-    ru->state = RU_RUN;
-  } else if (ru->has_ctrl_prt == 0) {
     // There is no control port: start everything here
     LOG_I(PHY, "RU %d has no OAI ctrl port\n",ru->idx);
 
@@ -1695,18 +1614,22 @@ static void *ru_thread( void *param ) {
     } else wait_sync("ru_thread"); 
     LOG_D(PHY,"RU %d: Got start from control thread\n",ru->idx);
 
-    if(!(ru->emulate_rf)) {
+    if (ru->is_slave == 0)
-      if (ru->is_slave == 0) AssertFatal(ru->state == RU_RUN,"ru-%d state = %s != RU_RUN\n",ru->idx,ru_states[ru->state]);
+      AssertFatal(ru->state == RU_RUN, "ru-%d state = %s != RU_RUN\n", ru->idx, ru_states[ru->state]);
-      else if (ru->is_slave == 1) AssertFatal(ru->state == RU_SYNC || ru->state == RU_RUN ||
+    else if (ru->is_slave == 1)
-                                                ru->state == RU_CHECK_SYNC,"ru %d state = %s != RU_SYNC or RU_RUN or RU_CHECK_SYNC\n",ru->idx,ru_states[ru->state]);
+      AssertFatal(ru->state == RU_SYNC || ru->state == RU_RUN || ru->state == RU_CHECK_SYNC,
+                  "ru %d state = %s != RU_SYNC or RU_RUN or RU_CHECK_SYNC\n",
+                  ru->idx,
+                  ru_states[ru->state]);
 
-      // Start RF device if any
+    // Start RF device if any
-      if (ru->start_rf) {
+    if (ru->start_rf) {
-	if (ru->start_rf(ru) != 0)
+      if (ru->start_rf(ru) != 0)
-	  AssertFatal(1==0,"Could not start the RF device\n");
+        AssertFatal(1 == 0, "Could not start the RF device\n");
-	else LOG_I(PHY,"RU %d rf device ready\n",ru->idx);
+      else
-      } else LOG_D(PHY,"RU %d no rf device\n",ru->idx);
+        LOG_I(PHY, "RU %d rf device ready\n", ru->idx);
-    }
+    } else
+      LOG_D(PHY, "RU %d no rf device\n", ru->idx);
 
     // if an asnych_rxtx thread exists
     // wakeup the thread because the devices are ready at this point
@@ -1864,26 +1787,13 @@ static void *ru_thread( void *param ) {
           // do OFDM if needed
           if ((ru->fh_north_asynch_in == NULL) && (ru->feptx_ofdm)) ru->feptx_ofdm(ru, proc->frame_tx, proc->tti_tx);
 
-          if(!(ru->emulate_rf)) { //if(!emulate_rf){
+          // do outgoing fronthaul (south) if needed
-            // do outgoing fronthaul (south) if needed
+          if ((ru->fh_north_asynch_in == NULL) && (ru->fh_south_out))
-            if ((ru->fh_north_asynch_in == NULL) && (ru->fh_south_out)) ru->fh_south_out(ru, proc->frame_tx, proc->tti_tx, proc->timestamp_tx);
+            ru->fh_south_out(ru, proc->frame_tx, proc->tti_tx, proc->timestamp_tx);
 
-            if ((ru->fh_north_out) && (ru->state!=RU_CHECK_SYNC)) ru->fh_north_out(ru);
+          if ((ru->fh_north_out) && (ru->state != RU_CHECK_SYNC))
-          } else {
+            ru->fh_north_out(ru);
-            for (int i=0; i<ru->nb_tx; i++) {
-              if(proc->frame_tx == 2) {
-                sprintf(filename,"txdataF%d_frame%d_sf%d.m",i,proc->frame_tx,proc->tti_tx);
-                LOG_M(filename,"txdataF_frame",ru->common.txdataF_BF[i],ru->frame_parms->symbols_per_tti*ru->frame_parms->ofdm_symbol_size, 1, 1);
-              }
 
-              if(proc->frame_tx == 2 && proc->tti_tx==0) {
-                sprintf(filename,"txdata%d_frame%d.m",i,proc->frame_tx);
-                LOG_M(filename,"txdata_frame",ru->common.txdata[i],ru->frame_parms->samples_per_tti*10, 1, 1);
-              }
-            }
-          }
-
-          proc->emulate_rf_busy = 0;
         }
 
 #else
@@ -1903,12 +1813,11 @@ static void *ru_thread( void *param ) {
 
   LOG_I(PHY, "Exiting ru_thread \n");
 
-  if (!(ru->emulate_rf)) {
+  if (ru->stop_rf != NULL) {
-    if (ru->stop_rf != NULL) {
+    if (ru->stop_rf(ru) != 0)
-      if (ru->stop_rf(ru) != 0)
+      LOG_E(HW, "Could not stop the RF device\n");
-        LOG_E(HW,"Could not stop the RF device\n");
+    else
-      else LOG_I(PHY,"RU %d rf device stopped\n",ru->idx);
+      LOG_I(PHY, "RU %d rf device stopped\n", ru->idx);
-    }
   }
 
   return NULL;
@@ -2128,12 +2037,12 @@ static void *rf_tx( void *param ) {
       // do OFDM if needed
       if ((ru->fh_north_asynch_in == NULL) && (ru->feptx_ofdm)) ru->feptx_ofdm(ru,proc->frame_tx,proc->tti_tx);
 
-      if(!ru->emulate_rf) {
+      // do outgoing fronthaul (south) if needed
-        // do outgoing fronthaul (south) if needed
+      if ((ru->fh_north_asynch_in == NULL) && (ru->fh_south_out))
-        if ((ru->fh_north_asynch_in == NULL) && (ru->fh_south_out)) ru->fh_south_out(ru,proc->frame_tx,proc->tti_tx,proc->timestamp_tx);
+        ru->fh_south_out(ru, proc->frame_tx, proc->tti_tx, proc->timestamp_tx);
 
-        if (ru->fh_north_out) ru->fh_north_out(ru);
+      if (ru->fh_north_out)
-      }
+        ru->fh_north_out(ru);
     }
 
     if (release_thread(&proc->mutex_rf_tx,&proc->instance_cnt_rf_tx,"rf_tx") < 0) break;
@@ -2205,7 +2114,7 @@ int start_write_thread(RU_t *ru) {
 void init_RU_proc(RU_t *ru) {
   int i=0;
   RU_proc_t *proc;
-  pthread_attr_t *attr_FH=NULL, *attr_FH1=NULL, *attr_prach=NULL, *attr_asynch=NULL, *attr_synch=NULL, *attr_emulateRF=NULL, *attr_ctrl=NULL, *attr_prach_br=NULL;
+  pthread_attr_t *attr_FH=NULL, *attr_FH1=NULL, *attr_prach=NULL, *attr_asynch=NULL, *attr_synch=NULL, *attr_ctrl=NULL, *attr_prach_br=NULL;
   //pthread_attr_t *attr_fep=NULL;
   LOG_I(PHY,"Initializing RU proc %d (%s,%s),\n",ru->idx,NB_functions[ru->function],NB_timing[ru->if_timing]);
   proc = &ru->proc;
@@ -2215,7 +2124,6 @@ void init_RU_proc(RU_t *ru) {
   proc->instance_cnt_synch       = -1;
   proc->instance_cnt_FH          = -1;
   proc->instance_cnt_FH1         = -1;
-  proc->instance_cnt_emulateRF   = -1;
   proc->instance_cnt_asynch_rxtx = -1;
   proc->instance_cnt_ru          = -1;
   proc->instance_cnt_eNBs        = -1;
@@ -2232,20 +2140,17 @@ void init_RU_proc(RU_t *ru) {
   pthread_mutex_init( &proc->mutex_synch,NULL);
   pthread_mutex_init( &proc->mutex_FH,NULL);
   pthread_mutex_init( &proc->mutex_FH1,NULL);
-  pthread_mutex_init( &proc->mutex_emulateRF,NULL);
   pthread_mutex_init( &proc->mutex_eNBs, NULL);
   pthread_mutex_init( &proc->mutex_ru,NULL);
   pthread_cond_init( &proc->cond_prach, NULL);
   pthread_cond_init( &proc->cond_FH, NULL);
   pthread_cond_init( &proc->cond_FH1, NULL);
-  pthread_cond_init( &proc->cond_emulateRF, NULL);
   pthread_cond_init( &proc->cond_asynch_rxtx, NULL);
   pthread_cond_init( &proc->cond_synch,NULL);
   pthread_cond_init( &proc->cond_eNBs, NULL);
   pthread_cond_init( &proc->cond_ru_thread,NULL);
   pthread_attr_init( &proc->attr_FH);
   pthread_attr_init( &proc->attr_FH1);
-  pthread_attr_init( &proc->attr_emulateRF);
   pthread_attr_init( &proc->attr_prach);
   pthread_attr_init( &proc->attr_synch);
   pthread_attr_init( &proc->attr_asynch_rxtx);
@@ -2289,9 +2194,6 @@ void init_RU_proc(RU_t *ru) {
   pthread_create( &proc->pthread_rf_tx, NULL, rf_tx, (void *)ru );
 #endif
 
-  if (ru->emulate_rf)
-    pthread_create( &proc->pthread_emulateRF, attr_emulateRF, emulatedRF_thread, (void *)proc );
-
   if (get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT || get_thread_parallel_conf() == PARALLEL_RU_L1_TRX_SPLIT)
     pthread_create( &proc->pthread_FH1, attr_FH1, ru_thread_tx, (void *)ru );
 

executables/lte-softmodem.c

@@ -138,7 +138,6 @@ RU_t **RCconfig_RU(int nb_RU,int nb_L1_inst,PHY_VARS_eNB ***eNB,uint64_t *ru_mas
 RU_t **RCconfig_RU(int nb_RU,int nb_L1_inst,PHY_VARS_eNB ***eNB,uint64_t *ru_mask,pthread_mutex_t *ru_mutex,pthread_cond_t *ru_cond);
 
 int transmission_mode=1;
-int emulate_rf = 0;
 int numerology = 0;
 
 THREAD_STRUCT thread_struct;

executables/lte-softmodem.h

@@ -127,7 +127,6 @@ extern int sync_var;
 extern int transmission_mode;
 extern double cpuf;
 
-extern int emulate_rf;
 extern int numerology;
 extern int usrp_tx_thread;
 

executables/nr-ru.c

@@ -567,25 +567,6 @@ void fh_if4p5_north_out(RU_t *ru) {
   stop_meas(&ru->tx_fhaul);
 }
 
-void *emulatedRF_thread(void *param) {
-  RU_proc_t *proc = (RU_proc_t *) param;
-  int microsec = 500; // length of time to sleep, in miliseconds
-  struct timespec req = {0};
-  req.tv_sec = 0;
-  req.tv_nsec = (numerology>0)? ((microsec * 1000L)/numerology):(microsec * 1000L)*2;
-  wait_sync("emulatedRF_thread");
-
-  while(!oai_exit) {
-    nanosleep(&req, (struct timespec *)NULL);
-    pthread_mutex_lock(&proc->mutex_emulateRF);
-    ++proc->instance_cnt_emulateRF;
-    pthread_mutex_unlock(&proc->mutex_emulateRF);
-    pthread_cond_signal(&proc->cond_emulateRF);
-  }
-
-  return 0;
-}
-
 static void rx_rf(RU_t *ru, int *frame, int *slot)
 {
   RU_proc_t *proc = &ru->proc;
@@ -606,14 +587,7 @@ static void rx_rf(RU_t *ru, int *frame, int *slot)
 
   openair0_timestamp ts;
   unsigned int rxs;
-  if(emulate_rf) {
+  rxs = ru->rfdevice.trx_read_func(&ru->rfdevice, &ts, rxp, samples_per_slot, nb);
-    wait_on_condition(&proc->mutex_emulateRF,&proc->cond_emulateRF,&proc->instance_cnt_emulateRF,"emulatedRF_thread");
-    release_thread(&proc->mutex_emulateRF,&proc->instance_cnt_emulateRF,"emulatedRF_thread");
-    rxs = samples_per_slot;
-    ts = old_ts + rxs;
-  } else {
-    rxs = ru->rfdevice.trx_read_func(&ru->rfdevice, &ts, rxp, samples_per_slot, nb);
-  }
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, 0 );
   proc->timestamp_rx = ts-ru->ts_offset;
@@ -683,10 +657,8 @@ static void rx_rf(RU_t *ru, int *frame, int *slot)
     *slot  = proc->tti_rx;
   }
 
-  if (!emulate_rf) {
+  metadata mt = {.slot = *slot, .frame = *frame};
-    metadata mt = {.slot = *slot, .frame = *frame};
+  gNBscopeCopyWithMetadata(ru, gNbTimeDomainSamples, rxp[0], sizeof(c16_t), 1, samples_per_slot, 0, &mt);
-    gNBscopeCopyWithMetadata(ru, gNbTimeDomainSamples, rxp[0], sizeof(c16_t), 1, samples_per_slot, 0, &mt);
-  }
 
   VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TS, (proc->timestamp_rx+ru->ts_offset)&0xffffffff );
 
@@ -996,11 +968,8 @@ void ru_tx_func(void *param)
 {
   processingData_RU_t *info = (processingData_RU_t *) param;
   RU_t *ru = info->ru;
-  NR_DL_FRAME_PARMS *fp = ru->nr_frame_parms;
   int frame_tx = info->frame_tx;
   int slot_tx = info->slot_tx;
-  int print_frame = 8;
-  char filename[40];
 
   // do TX front-end processing if needed (precoding and/or IDFTs)
   if (ru->feptx_prec)
@@ -1010,44 +979,12 @@ void ru_tx_func(void *param)
   if ((ru->fh_north_asynch_in == NULL) && (ru->feptx_ofdm))
     ru->feptx_ofdm(ru, frame_tx, slot_tx);
 
-  if(!emulate_rf) {
+  // do outgoing fronthaul (south) if needed
-    // do outgoing fronthaul (south) if needed
+  if ((ru->fh_north_asynch_in == NULL) && (ru->fh_south_out))
-    if ((ru->fh_north_asynch_in == NULL) && (ru->fh_south_out))
+    ru->fh_south_out(ru, frame_tx, slot_tx, info->timestamp_tx);
-      ru->fh_south_out(ru, frame_tx, slot_tx, info->timestamp_tx);
 
-    if (ru->fh_north_out)
+  if (ru->fh_north_out)
-      ru->fh_north_out(ru);
+    ru->fh_north_out(ru);
-  } else {
-    if(frame_tx == print_frame) {
-      for (int i = 0; i < ru->nb_tx * ru->num_beams_period; i++) {
-        if(slot_tx == 0) {
-          sprintf(filename,"gNBdataF_frame%d_sl%d.m", print_frame, slot_tx);
-          LOG_M(filename,"txdataF_frame",&ru->gNB_list[0]->common_vars.txdataF[i][0],fp->samples_per_frame_wCP, 1, 1);
-          sprintf(filename,"tx%ddataF_frame%d_sl%d.m", i, print_frame, slot_tx);
-          LOG_M(filename,"txdataF_frame",&ru->common.txdataF[i][0],fp->samples_per_frame_wCP, 1, 1);
-          sprintf(filename,"tx%ddataF_BF_frame%d_sl%d.m", i, print_frame, slot_tx);
-          LOG_M(filename,"txdataF_BF_frame",&ru->common.txdataF_BF[i][0],fp->samples_per_subframe_wCP, 1, 1);
-        }
-
-        if(slot_tx == 9) {
-          sprintf(filename,"tx%ddata_frame%d.m", i, print_frame);
-          LOG_M(filename,"txdata_frame",&ru->common.txdata[i][0],fp->samples_per_frame, 1, 1);
-          sprintf(filename,"tx%ddata_frame%d.dat", i, print_frame);
-          FILE *output_fd = fopen(filename,"w");
-
-          if (output_fd) {
-            fwrite(&ru->common.txdata[i][0],
-                   sizeof(int32_t),
-                   fp->samples_per_frame,
-                   output_fd);
-            fclose(output_fd);
-          } else {
-            LOG_E(PHY,"Cannot write to file %s\n",filename);
-          }
-        }//if(slot_tx == 9)
-      }//for (i=0; i<ru->nb_tx; i++)
-    }//if(frame_tx == print_frame)
-  }//else  emulate_rf
 }
 
 /* @brief wait for the next RX TTI to be free
@@ -1119,54 +1056,50 @@ void *ru_thread(void *param)
   fill_rf_config(ru, ru->rf_config_file);
   fill_split7_2_config(&ru->openair0_cfg.split7, &ru->config, fp->slots_per_frame, fp->ofdm_symbol_size);
 
-  if(!emulate_rf) {
+  // Start IF device if any
-    // Start IF device if any
+  if (ru->nr_start_if) {
-    if (ru->nr_start_if) {
+    LOG_I(PHY, "starting transport\n");
-      LOG_I(PHY, "starting transport\n");
+    ret = openair0_transport_load(&ru->ifdevice, &ru->openair0_cfg, &ru->eth_params);
-      ret = openair0_transport_load(&ru->ifdevice, &ru->openair0_cfg, &ru->eth_params);
+    AssertFatal(ret == 0, "RU %u: openair0_transport_init() ret %d: cannot initialize transport protocol\n", ru->idx, ret);
-      AssertFatal(ret == 0, "RU %u: openair0_transport_init() ret %d: cannot initialize transport protocol\n", ru->idx, ret);
-
-      if (ru->ifdevice.get_internal_parameter != NULL) {
-        /* it seems the device can "overwrite" (request?) to set the callbacks
-         * for fh_south_in()/fh_south_out() differently */
-        void *t = ru->ifdevice.get_internal_parameter("fh_if4p5_south_in");
-        if (t != NULL)
-          ru->fh_south_in = t;
-        t = ru->ifdevice.get_internal_parameter("fh_if4p5_south_out");
-        if (t != NULL)
-          ru->fh_south_out = t;
-      } else {
-
-        malloc_IF4p5_buffer(ru);
-      }
-
-      int cpu = sched_getcpu();
-      if (ru->ru_thread_core > -1 && cpu != ru->ru_thread_core) {
-        /* we start the ru_thread using threadCreate(), which already sets CPU
-         * affinity; let's force it here again as per feature request #732 */
-        cpu_set_t cpuset;
-        CPU_ZERO(&cpuset);
-        CPU_SET(ru->ru_thread_core, &cpuset);
-        int ret = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
-        AssertFatal(ret == 0, "Error in pthread_getaffinity_np(): ret: %d, errno: %d", ret, errno);
-        LOG_I(PHY, "RU %d: manually set CPU affinity to CPU %d\n", ru->idx, ru->ru_thread_core);
-      }
-
-      LOG_I(PHY,"Starting IF interface for RU %d, nb_rx %d\n",ru->idx,ru->nb_rx);
-      AssertFatal(ru->nr_start_if(ru,NULL) == 0, "Could not start the IF device\n");
-
-      if (ru->has_ctrl_prt > 0) {
-        if (ru->if_south == LOCAL_RF) ret = connect_rau(ru);
-        else ret = attach_rru(ru);
-  
-        AssertFatal(ret==0,"Cannot connect to remote radio\n");
-      }
 
+    if (ru->ifdevice.get_internal_parameter != NULL) {
+      /* it seems the device can "overwrite" (request?) to set the callbacks
+       * for fh_south_in()/fh_south_out() differently */
+      void *t = ru->ifdevice.get_internal_parameter("fh_if4p5_south_in");
+      if (t != NULL)
+        ru->fh_south_in = t;
+      t = ru->ifdevice.get_internal_parameter("fh_if4p5_south_out");
+      if (t != NULL)
+        ru->fh_south_out = t;
+    } else {
+      malloc_IF4p5_buffer(ru);
     }
-    else if (ru->if_south == LOCAL_RF) { // configure RF parameters only
+
-      ret = openair0_device_load(&ru->rfdevice,&ru->openair0_cfg);
+    int cpu = sched_getcpu();
-      AssertFatal(ret==0,"Cannot connect to local radio\n");
+    if (ru->ru_thread_core > -1 && cpu != ru->ru_thread_core) {
+      /* we start the ru_thread using threadCreate(), which already sets CPU
+       * affinity; let's force it here again as per feature request #732 */
+      cpu_set_t cpuset;
+      CPU_ZERO(&cpuset);
+      CPU_SET(ru->ru_thread_core, &cpuset);
+      int ret = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
+      AssertFatal(ret == 0, "Error in pthread_getaffinity_np(): ret: %d, errno: %d", ret, errno);
+      LOG_I(PHY, "RU %d: manually set CPU affinity to CPU %d\n", ru->idx, ru->ru_thread_core);
     }
+
+    LOG_I(PHY,"Starting IF interface for RU %d, nb_rx %d\n",ru->idx,ru->nb_rx);
+    AssertFatal(ru->nr_start_if(ru,NULL) == 0, "Could not start the IF device\n");
+
+    if (ru->has_ctrl_prt > 0) {
+      if (ru->if_south == LOCAL_RF) ret = connect_rau(ru);
+      else ret = attach_rru(ru);
+
+      AssertFatal(ret==0,"Cannot connect to remote radio\n");
+    }
+
+  } else if (ru->if_south == LOCAL_RF) { // configure RF parameters only
+    ret = openair0_device_load(&ru->rfdevice,&ru->openair0_cfg);
+    AssertFatal(ret==0,"Cannot connect to local radio\n");
   }
 
   if (setup_RU_buffers(ru)!=0) {
@@ -1181,23 +1114,23 @@ void *ru_thread(void *param)
   pthread_mutex_unlock(&RC.ru_mutex);
   wait_sync("ru_thread");
 
-  if(!emulate_rf) {
+  // Start RF device if any
-    // Start RF device if any
+  if (ru->start_rf) {
-    if (ru->start_rf) {
+    if (ru->start_rf(ru) != 0)
-      if (ru->start_rf(ru) != 0)
+      LOG_E(HW, "Could not start the RF device\n");
-        LOG_E(HW,"Could not start the RF device\n");
+    else
-      else LOG_I(PHY,"RU %d rf device ready\n",ru->idx);
+      LOG_I(PHY, "RU %d rf device ready\n", ru->idx);
-    } else LOG_I(PHY,"RU %d no rf device\n",ru->idx);
+  } else
+    LOG_I(PHY, "RU %d no rf device\n", ru->idx);
 
-    LOG_I(PHY, "RU %d RF started cpu_meas_enabled %d\n", ru->idx, cpu_meas_enabled);
+  LOG_I(PHY, "RU %d RF started cpu_meas_enabled %d\n", ru->idx, cpu_meas_enabled);
-    // start trx write thread
+  // start trx write thread
-    if(usrp_tx_thread == 1) {
+  if (usrp_tx_thread == 1) {
-      if (ru->start_write_thread) {
+    if (ru->start_write_thread) {
-        if(ru->start_write_thread(ru) != 0) {
+      if (ru->start_write_thread(ru) != 0) {
-          LOG_E(HW,"Could not start tx write thread\n");
+        LOG_E(HW, "Could not start tx write thread\n");
-        } else {
+      } else {
-          LOG_I(PHY,"tx write thread ready\n");
+        LOG_I(PHY, "tx write thread ready\n");
-        }
       }
     }
   }
@@ -1358,7 +1291,6 @@ void init_RU_proc(RU_t *ru) {
   proc = &ru->proc;
   memset((void *)proc,0,sizeof(RU_proc_t));
   proc->ru = ru;
-  proc->instance_cnt_emulateRF   = -1;
   proc->first_rx                 = 1;
   proc->first_tx                 = 1;
   proc->frame_offset             = 0;
@@ -1367,11 +1299,6 @@ void init_RU_proc(RU_t *ru) {
 
   for (i=0; i<10; i++) proc->symbol_mask[i]=0;
 
-  pthread_mutex_init( &proc->mutex_emulateRF,NULL);
-  pthread_cond_init( &proc->cond_emulateRF, NULL);
-
-  if(emulate_rf)
-    threadCreate( &proc->pthread_emulateRF, emulatedRF_thread, (void *)proc, "emulateRF", -1, OAI_PRIORITY_RT );
   LOG_I(PHY, "Initialized RU proc %d (%s,%s),\n", ru->idx, NB_functions[ru->function], NB_timing[ru->if_timing]);
 }
 

executables/nr-softmodem-common.h

@@ -133,7 +133,6 @@ extern int sync_var;
 extern int transmission_mode;
 extern double cpuf;
 
-extern int emulate_rf;
 extern int numerology;
 extern int usrp_tx_thread;
 void wait_gNBs(void);

executables/nr-softmodem.c

@@ -119,7 +119,6 @@ double rx_gain_off = 0.0;
 
 static int tx_max_power[MAX_NUM_CCs]; /* =  {0,0}*/;
 int chain_offset = 0;
-int emulate_rf = 0;
 int numerology = 0;
 double cpuf;
 

executables/softmodem-common.h

@@ -96,7 +96,6 @@ extern "C"
 
 #define CONFIG_HLP_NUMEROLOGY    "adding numerology for 5G\n"
 #define CONFIG_HLP_BAND          "band index\n"
-#define CONFIG_HLP_EMULATE_RF    "Emulated RF enabled(disable by defult)\n"
 #define CONFIG_HLP_PARALLEL_CMD  "three config for level of parallelism 'PARALLEL_SINGLE_THREAD', 'PARALLEL_RU_L1_SPLIT', or 'PARALLEL_RU_L1_TRX_SPLIT'\n"
 #define CONFIG_HLP_WORKER_CMD    "two option for worker 'WORKER_DISABLE' or 'WORKER_ENABLE'\n"
 #define CONFIG_HLP_USRP_THREAD   "having extra thead for usrp tx\n"
@@ -128,7 +127,6 @@ extern "C"
 #define CHAIN_OFFSET        softmodem_params.chain_offset
 #define NUMEROLOGY          softmodem_params.numerology
 #define BAND                softmodem_params.band
-#define EMULATE_RF          softmodem_params.emulate_rf
 #define CLOCK_SOURCE        softmodem_params.clock_source
 #define TIMING_SOURCE       softmodem_params.timing_source
 #define TUNE_OFFSET         softmodem_params.tune_offset
@@ -164,7 +162,6 @@ extern int usrp_tx_thread;
   {"q" ,                    CONFIG_HLP_STMON,         PARAMFLAG_BOOL, .iptr=&cpu_meas_enabled,                     .defintval=0,             TYPE_INT,    0},  \
   {"numerology" ,           CONFIG_HLP_NUMEROLOGY,    0,              .iptr=&NUMEROLOGY,                      .defintval=1,             TYPE_INT,    0},  \
   {"band" ,                 CONFIG_HLP_BAND,          0,              .iptr=&BAND,                            .defintval=78,            TYPE_INT,    0},  \
-  {"emulate-rf" ,           CONFIG_HLP_EMULATE_RF,    PARAMFLAG_BOOL, .iptr=&EMULATE_RF,                      .defintval=0,             TYPE_INT,    0},  \
   {"parallel-config",       CONFIG_HLP_PARALLEL_CMD,  0,              .strptr=&parallel_config,               .defstrval=NULL,          TYPE_STRING, 0},  \
   {"worker-config",         CONFIG_HLP_WORKER_CMD,    0,              .strptr=&worker_config,                 .defstrval=NULL,          TYPE_STRING, 0},  \
   {"noS1",                  CONFIG_HLP_NOS1,          PARAMFLAG_BOOL, .uptr=&noS1,                            .defintval=0,             TYPE_UINT,   0},  \
@@ -217,7 +214,6 @@ extern int usrp_tx_thread;
     { .s5 = { NULL } },                     \
     { .s5 = { NULL } },                     \
     { .s5 = { NULL } },                     \
-    { .s5 = { NULL } },                     \
     { .s3a = { config_checkstr_assign_integer, \
                {"MONOLITHIC", "PNF", "VNF", "AERIAL","UE_STUB_PNF","UE_STUB_OFFNET","STANDALONE_PNF"}, \
                {NFAPI_MONOLITHIC, NFAPI_MODE_PNF, NFAPI_MODE_VNF, NFAPI_MODE_AERIAL,NFAPI_UE_STUB_PNF,NFAPI_UE_STUB_OFFNET,NFAPI_MODE_STANDALONE_PNF}, \
@@ -320,7 +316,6 @@ typedef struct {
   int            phy_test;
   int            do_ra;
   uint8_t        sl_mode;
-  int            emulate_rf;
   int            chain_offset;
   int            numerology;
   int            band;

openair1/PHY/defs_RU.h

@@ -255,7 +255,6 @@ typedef struct RU_proc_t_s {
   int instance_cnt_feptx;
   /// \internal This variable is protected by \ref mutex_ru_thread
   int instance_cnt_ru;
-  int instance_cnt_emulateRF;
   /// pthread structure for RU FH processing thread
   pthread_t pthread_FH;
   pthread_t pthread_FH1;
@@ -271,8 +270,6 @@ typedef struct RU_proc_t_s {
   pthread_t pthread_fep[8];
   /// pthread struct for RU TX FEP worker thread
   pthread_t pthread_feptx;
-  /// pthread struct for emulated RF
-  pthread_t pthread_emulateRF;
   /// pthread structure for asychronous RX/TX processing thread
   pthread_t pthread_asynch_rxtx;
   /// flag to indicate first RX acquisition
@@ -296,8 +293,6 @@ typedef struct RU_proc_t_s {
   pthread_attr_t attr_fep;
   /// pthread attributes for worker feptx thread
   pthread_attr_t attr_feptx;
-  /// pthread attributes for emulated RF
-  pthread_attr_t attr_emulateRF;
   /// scheduling parameters for RU FH thread
   struct sched_param sched_param_FH;
   struct sched_param sched_param_FH1;
@@ -324,8 +319,6 @@ typedef struct RU_proc_t_s {
   pthread_cond_t cond_fep[8];
   /// condition varible for RU TX FEP thread
   pthread_cond_t cond_feptx;
-  /// condition varible for emulated RF
-  pthread_cond_t cond_emulateRF;
   /// condition variable for eNB signal
   pthread_cond_t cond_eNBs;
   /// condition variable for gNB signal
@@ -353,8 +346,6 @@ typedef struct RU_proc_t_s {
   pthread_mutex_t mutex_feptx;
   /// mutex for ru_thread
   pthread_mutex_t mutex_ru;
-  /// mutex for emulated RF thread
-  pthread_mutex_t mutex_emulateRF;
   /// symbol mask for IF4p5 reception per subframe
   uint32_t symbol_mask[10];
   /// time measurements for each subframe
@@ -394,7 +385,6 @@ typedef struct RU_proc_t_s {
   /// pipeline ready state
   int ru_rx_ready;
   int ru_tx_ready;
-  int emulate_rf_busy;
 
   /// structure for precoding thread
   RU_prec_t prec[16];
@@ -407,7 +397,6 @@ typedef enum {
   REMOTE_IF4p5    =3,
   REMOTE_IF1pp    =4,
   MAX_RU_IF_TYPES =5
-                   //EMULATE_RF      =6
 } RU_if_south_t;
 
 
@@ -453,8 +442,6 @@ typedef struct RU_t_s {
   node_function_t function;
   /// Ethernet parameters for fronthaul interface
   eth_params_t eth_params;
-  /// flag to indicate RF emulation mode
-  int emulate_rf;
   /// numerology index
   int numerology;
   /// flag to indicate the RU is in sync with a master reference

openair1/PHY/defs_eNB.h

@@ -255,11 +255,6 @@ typedef struct {
   tpool_t *threadPool;
   int nbDecode;
   notifiedFIFO_t *respDecode;
-  pthread_mutex_t mutex_emulateRF;
-  int instance_cnt_emulateRF;
-  pthread_t pthread_emulateRF;
-  pthread_attr_t attr_emulateRF;
-  pthread_cond_t cond_emulateRF;
   int first_rx;
 } L1_rxtx_proc_t;
 

openair1/SIMULATION/LTE_PHY/dlsim.c

@@ -90,7 +90,6 @@ static int cmpdouble(const void *p1, const void *p2) {
 }
 RAN_CONTEXT_t RC;
 
-int emulate_rf = 0;
 void handler(int sig) {
   void *array[10];
   size_t size;

openair1/SIMULATION/LTE_PHY/mbmssim.c

@@ -89,8 +89,6 @@ int n_rx_dropped = 0; /*!< \brief initial max process time for rx */
 
 THREAD_STRUCT thread_struct;
 
-int emulate_rf = 0;
-
 void handler(int sig) {
   void *array[10];
   size_t size;