Merge branch 'develop' into improve_nr_modulation

openair1/PHY/LTE_UE_TRANSPORT/prach_ue.c

@@ -55,7 +55,7 @@ int32_t generate_prach( PHY_VARS_UE *ue, uint8_t eNB_id, uint8_t subframe, uint1
   uint8_t preamble_index     = ue->prach_resources[eNB_id]->ra_PreambleIndex;
   uint8_t tdd_mapindex       = ue->prach_resources[eNB_id]->ra_TDD_map_index;
   int16_t *prachF           = ue->prach_vars[eNB_id]->prachF;
-  static int16_t prach_tmp[45600*2] __attribute__((aligned(32)));
+  static int16_t prach_tmp[45600*4] __attribute__((aligned(32)));
   int16_t *prach            = prach_tmp;
   int16_t *prach2;
   int16_t amp               = ue->prach_vars[eNB_id]->amp;

openair1/PHY/NR_TRANSPORT/nr_prach.c

@@ -540,7 +540,7 @@ void rx_nr_prach(PHY_VARS_gNB *gNB,
   uint16_t           rootSequenceIndex;  
   int                numrootSequenceIndex;
   uint8_t            restricted_set;      
-  uint8_t            n_ra_prb;
+  uint8_t            n_ra_prb=0xFF;
   int16_t            *prachF=NULL;
   int                nb_rx;
 

openair1/PHY/TOOLS/nr_phy_scope.c

@@ -26,6 +26,7 @@
 #include <stdlib.h>
 #include "nr_phy_scope.h"
 #include "executables/nr-softmodem-common.h"
+#include "executables/softmodem-common.h"
 #include <forms.h>
 
 #define TPUT_WINDOW_LENGTH 100
@@ -768,6 +769,15 @@ void nrUEinitScope(PHY_VARS_NR_UE *ue) {
   threadCreate(&forms_thread, nrUEscopeThread, ue, "scope", -1, OAI_PRIORITY_RT_LOW);
 }
 
+
+void nrscope_autoinit(void *dataptr) {
+  AssertFatal( (IS_SOFTMODEM_GNB_BIT||IS_SOFTMODEM_5GUE_BIT),"Scope cannot find NRUE or GNB context");
+  
+  if (IS_SOFTMODEM_GNB_BIT)
+  	 gNBinitScope(dataptr);
+  else
+     nrUEinitScope(dataptr);
+}
 // Kept to put back the functionality soon
 #if 0
 //FD_stats_form                  *form_stats=NULL,*form_stats_l2=NULL;
@@ -795,6 +805,8 @@ static void reset_stats_gNB(FL_OBJECT *button,
   }
 }
 
+
+
 static FD_stats_form *create_form_stats_form(int ID) {
   FL_OBJECT *obj;
   FD_stats_form *fdui = calloc(( sizeof *fdui ),1);

openair1/PHY/TOOLS/nr_phy_scope.h

@@ -40,8 +40,6 @@ typedef struct {
   PHY_VARS_gNB *gNB;
 } scopeParms_t;
 
-void gNBinitScope(scopeParms_t *p);
-void nrUEinitScope(PHY_VARS_NR_UE *ue);
 
 extern RAN_CONTEXT_t RC;
 #endif

openair1/PHY/TOOLS/phy_scope_interface.c

@@ -37,10 +37,10 @@
 #define SOFTSCOPE_ENDFUNC_IDX 0
 static  loader_shlibfunc_t scope_fdesc[]= {{"end_forms",NULL}};
 
-int load_softscope(char *exectype) {
+int load_softscope(char *exectype, void *initarg) {
   char libname[64];
   sprintf(libname,"%.10sscope",exectype);
-  return load_module_shlib(libname,scope_fdesc,1,NULL);
+  return load_module_shlib(libname,scope_fdesc,1,initarg);
 }
 
 int end_forms(void) {

openair1/PHY/TOOLS/phy_scope_interface.h

@@ -31,5 +31,5 @@
  */
 
 
-int load_softscope(char *exectype);
+int load_softscope(char *exectype, void *initarg);
 int end_forms(void) ;

openair1/PHY/TOOLS/readme.md

@@ -0,0 +1,12 @@
+
+To use the scope, run the xNB or the UE with option "-d"  
+
+Usage in gdb
+In gdb, when you break, you can refresh immediatly the scope view by calling the display function.
+The first paramter is the graph context, nevertheless we keep the last value for a dirty call in gdb (so you can use '0')  
+
+Example with no variable known
+phy_scope_nrUE(0, PHY_vars_UE_g[0][0], 0, 0, 0)
+
+or
+phy_scope_gNB(0, phy_vars_gnb, phy_vars_ru, UE_id)

openair1/PHY/phy_vars.h

@@ -59,10 +59,10 @@ const short conjugate2[8]__attribute__((aligned(16))) = {1,-1,1,-1,1,-1,1,-1};
 unsigned char NB_RU=0;
 
 #ifndef OPENAIR2
-unsigned char NB_eNB_INST=0;
-uint16_t NB_UE_INST=0;
-unsigned char NB_RN_INST=0;
-unsigned char NB_INST=0;
+//unsigned char NB_eNB_INST=0;
+//uint16_t NB_UE_INST=0;
+//unsigned char NB_RN_INST=0;
+//unsigned char NB_INST=0;
 #endif
 
 int number_of_cards;

openair1/PHY/phy_vars_nr_ue.h

@@ -138,4 +138,4 @@ uint8_t scrambling_lut[65536*16] __attribute__((aligned(32)));
 uint8_t max_ldpc_iterations=4;
 uint8_t max_turbo_iterations=4;
 
-#endif /*__PHY_VARS_H__ */
+#endif

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -424,7 +424,7 @@ void phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx)
   for (int ULSCH_id=0;ULSCH_id<NUMBER_OF_NR_ULSCH_MAX;ULSCH_id++) {
     NR_gNB_ULSCH_t *ulsch = gNB->ulsch[ULSCH_id][0];
     int harq_pid;
-    int no_sig;
+    //int no_sig;
     NR_UL_gNB_HARQ_t *ulsch_harq;
 
     if ((ulsch) &&

openair1/SIMULATION/TOOLS/random_channel.c

@@ -45,8 +45,12 @@ static mapping channelmod_names[] = {
 };
 
 static int channelmod_show_cmd(char *buff, int debug, telnet_printfunc_t prnt);
+static int channelmod_modify_cmd(char *buff, int debug, telnet_printfunc_t prnt);
+static int channelmod_print_help(char *buff, int debug, telnet_printfunc_t prnt);
 static telnetshell_cmddef_t channelmod_cmdarray[] = {
-  {"show","",channelmod_show_cmd},
+  {"help","",channelmod_print_help},
+  {"show","<predef,current>",channelmod_show_cmd},
+  {"modify","<channelid> <param> <value>",channelmod_modify_cmd},  
   {"","",NULL},
 };
 
@@ -56,14 +60,15 @@ static telnetshell_vardef_t channelmod_vardef[] = {
 
 static double snr_dB=25;
 static double sinr_dB=0;
-
+static unsigned int max_chan;
+static channel_desc_t**  defined_channels;
 void fill_channel_desc(channel_desc_t *chan_desc,
                        uint8_t nb_tx,
                        uint8_t nb_rx,
                        uint8_t nb_taps,
                        uint8_t channel_length,
                        double *amps,
-                       double *delays,
+                       double *delays,                         
                        struct complex **R_sqrt,
                        double Td,
                        double sampling_rate,
@@ -88,6 +93,7 @@ void fill_channel_desc(channel_desc_t *chan_desc,
 
   if (delays==NULL) {
     chan_desc->delays = (double *) malloc(nb_taps*sizeof(double));
+    chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_DELAY ;
     delta_tau = Td/nb_taps;
 
     for (i=0; i<nb_taps; i++)
@@ -129,10 +135,9 @@ void fill_channel_desc(channel_desc_t *chan_desc,
 
   if (R_sqrt == NULL) {
     chan_desc->R_sqrt         = (struct complex **) calloc(nb_taps,sizeof(struct complex *));
-
+    chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_RSQRT_NTAPS ;
     for (i = 0; i<nb_taps; i++) {
-      chan_desc->R_sqrt[i]    = (struct complex *) calloc(nb_tx*nb_rx*nb_tx*nb_rx,sizeof(struct complex));
-
+      chan_desc->R_sqrt[i]    = (struct complex *) calloc(nb_tx*nb_rx*nb_tx*nb_rx,sizeof(struct complex));      
       for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) {
         chan_desc->R_sqrt[i][j].x = 1.0;
         chan_desc->R_sqrt[i][j].y = 0.0;
@@ -140,7 +145,7 @@ void fill_channel_desc(channel_desc_t *chan_desc,
     }
   } else {
     chan_desc->R_sqrt = (struct complex **) calloc(nb_taps,sizeof(struct complex *));
-
+     
     for (i = 0; i<nb_taps; i++) {
       //chan_desc->R_sqrt[i]    = (struct complex*) calloc(nb_tx*nb_rx*nb_tx*nb_rx,sizeof(struct complex));
       //chan_desc->R_sqrt = (struct complex*)&R_sqrt[i][0];
@@ -170,7 +175,7 @@ void fill_channel_desc(channel_desc_t *chan_desc,
 double mbsfn_delays[] = {0,.03,.15,.31,.37,1.09,12.490,12.52,12.64,12.80,12.86,13.58,27.49,27.52,27.64,27.80,27.86,28.58};
 double mbsfn_amps_dB[] = {0,-1.5,-1.4,-3.6,-0.6,-7.0,-10,-11.5,-11.4,-13.6,-10.6,-17.0,-20,-21.5,-21.4,-23.6,-20.6,-27};
 
-double scm_c_delays[] = {0, 0.0125, 0.0250, 0.3625, 0.3750, 0.3875, 0.2500, 0.2625, 0.2750, 1.0375, 1.0500, 1.0625, 2.7250, 2.7375, 2.7500, 4.6000, 4.6125, 4.6250};
+double scm_c_delays[] = {0, 0.0125, 0.0250, 0.3625, 0.3750, 0.3875, 0.2500, 0.2625, 0.2750, 1.0375, 1.0500, 1.0625, 2.7250, 2.7375, 2.7500, 4.6000, 4.6125, 4.6250};                
 double scm_c_amps_dB[] = {0.00, -2.22, -3.98, -1.86, -4.08, -5.84, -1.08, -3.30, -5.06, -9.08, -11.30, -13.06, -15.14, -17.36, -19.12, -20.64, -22.85, -24.62};
 
 double epa_delays[] = { 0,.03,.07,.09,.11,.19,.41};
@@ -277,14 +282,26 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
                                      SCM_t channel_model,
                                      double sampling_rate,
                                      double channel_bandwidth,
-                                     double forgetting_factor,
+                                     double forgetting_factor,              
                                      int32_t channel_offset,
                                      double path_loss_dB) {
-  channel_desc_t *chan_desc = (channel_desc_t *)malloc(sizeof(channel_desc_t));
+  channel_desc_t *chan_desc = (channel_desc_t *)calloc(1,sizeof(channel_desc_t));
+  for(int i=0; i<max_chan;i++) {
+  	  if (defined_channels[i] == NULL) {
+  	  	  defined_channels[i]=chan_desc;                             
+  	  	  chan_desc->chan_idx=i;
+  	      break;
+  	  }
+  	  else {
+  	  	 AssertFatal(i<(max_chan-1),
+              "No more channel descriptors available, increase channelmod.max_chan parameter above %u\n",max_chan);
+  	  }
+  }
   uint16_t i,j;
   double sum_amps;
   double aoa,ricean_factor,Td,maxDoppler;
   int channel_length,nb_taps;
+  chan_desc->modelid                   = channel_model;
   chan_desc->nb_tx                      = nb_tx;
   chan_desc->nb_rx                      = nb_rx;
   chan_desc->sampling_rate              = sampling_rate;
@@ -313,7 +330,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;         
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*scm_c_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -351,9 +368,10 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
         for (i = 0; i<6; i++)
           chan_desc->R_sqrt[i] = (struct complex *) &R12_sqrt[i][0];
       } else {
+      	chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_RSQRT_6 ; 
         for (i = 0; i<6; i++) {
           chan_desc->R_sqrt[i]    = (struct complex *) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
-
+           
           for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) {
             chan_desc->R_sqrt[i][j].x = 1.0;
             chan_desc->R_sqrt[i][j].y = 0.0;
@@ -372,7 +390,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*scm_c_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -410,6 +428,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
         for (i = 0; i<6; i++)
           chan_desc->R_sqrt[i] = (struct complex *) &R12_sqrt[i][0];
       } else {
+      	chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_RSQRT_6 ;
         for (i = 0; i<6; i++) {
           chan_desc->R_sqrt[i]    = (struct complex *) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
 
@@ -423,14 +442,14 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       }
 
       break;
-
+                               
     case EPA:
       chan_desc->nb_taps        = 7;
       chan_desc->Td             = .410;
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*epa_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -449,7 +468,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
 
       for (i = 0; i<nb_tx*nb_rx; i++)
         chan_desc->ch[i] = (struct complex *) malloc(chan_desc->channel_length * sizeof(struct complex));
-
+                                                                                          
       for (i = 0; i<nb_tx*nb_rx; i++)
         chan_desc->chF[i] = (struct complex *) malloc(1200 * sizeof(struct complex));
 
@@ -463,7 +482,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
           chan_desc->R_sqrt[i] = (struct complex *) &R22_sqrt[i][0];
       } else {
         chan_desc->R_sqrt         = (struct complex **) malloc(6*sizeof(struct complex **));
-
+        chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_RSQRT_6 ;
         for (i = 0; i<6; i++) {
           chan_desc->R_sqrt[i]    = (struct complex *) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
 
@@ -484,7 +503,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*epa_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -530,7 +549,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
           LOG_W(OCM,"correlation matrix only implemented for nb_tx==2 and nb_rx==2, using identity\n");
         }
       }*/
-      break;
+      break;             
 
     case EPA_high:
       chan_desc->nb_taps        = 7;
@@ -538,7 +557,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*epa_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -592,7 +611,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+       chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*epa_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -646,7 +665,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*eva_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -679,8 +698,8 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
           chan_desc->R_sqrt[i] = (struct complex *) &R22_sqrt[i][0];
       } else {
         chan_desc->R_sqrt         = (struct complex **) malloc(6*sizeof(struct complex **));
-
-        for (i = 0; i<6; i++) {
+        chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_RSQRT_6 ;
+        for (i = 0; i<6; i++) { 
           chan_desc->R_sqrt[i]    = (struct complex *) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
 
           for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) {
@@ -700,7 +719,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*etu_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -733,7 +752,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
           chan_desc->R_sqrt[i] = (struct complex *) &R22_sqrt[i][0];
       } else {
         chan_desc->R_sqrt         = (struct complex **) malloc(6*sizeof(struct complex **));
-
+        chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_RSQRT_6 ;
         for (i = 0; i<6; i++) {
           chan_desc->R_sqrt[i]    = (struct complex *) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
 
@@ -754,7 +773,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*mbsfn_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -781,7 +800,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
         chan_desc->a[i]         = (struct complex *) malloc(nb_tx*nb_rx * sizeof(struct complex));
 
       chan_desc->R_sqrt  = (struct complex **) malloc(6*sizeof(struct complex *));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_RSQRT_6;
       for (i = 0; i<6; i++) {
         chan_desc->R_sqrt[i]    = (struct complex *) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
 
@@ -1292,10 +1311,37 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
   chan_desc->nb_paths = 10;
   return(chan_desc);
 }
-
+     
 void free_channel_desc_scm(channel_desc_t *ch) {
   // Must be made cleanly, a lot of leaks...
-  free(ch);
+  defined_channels[ch->chan_idx]=NULL; 
+  if(ch->free_flags&CHANMODEL_FREE_AMPS)
+    free(ch->amps);
+  for (int i = 0; i<ch->nb_tx*ch->nb_rx; i++) { 
+    free(ch->ch[i]);
+    free(ch->chF[i]);
+  }
+            
+  for (int i = 0; i<ch->nb_taps; i++) {
+    free(ch->a[i]);              
+  }   
+  if(ch->free_flags&CHANMODEL_FREE_DELAY)
+    free(ch->delays);  
+  if(ch->free_flags&CHANMODEL_FREE_RSQRT_6)
+    for (int i = 0; i<6; i++)  
+      free(ch->R_sqrt[i]);             
+  if(ch->free_flags&CHANMODEL_FREE_RSQRT_NTAPS)
+    for (int i = 0; i<ch->nb_taps;i++)  
+      free(ch->R_sqrt[i]); 
+  free(ch->R_sqrt);        
+  free(ch->ch); 
+  free(ch->chF);
+  free(ch->a);  
+  free(ch);                                          
+}
+
+void set_channeldesc_owner(channel_desc_t *cdesc, uint32_t module_id) {
+	cdesc->module_id=module_id;
 }
 
 int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) {
@@ -1408,11 +1454,11 @@ int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) {
             desc->ch[aarx+(aatx*desc->nb_rx)][k].y = 0.0;
 
             for (l=0; l<desc->nb_taps; l++) {
-              if ((k - (desc->delays[l]*desc->sampling_rate) - NB_SAMPLES_CHANNEL_OFFSET) == 0)
+              if ((k - (desc->delays[l]*desc->sampling_rate) - desc->channel_offset) == 0)
                 s = 1.0;
               else
-                s = sin(M_PI*(k - (desc->delays[l]*desc->sampling_rate) - NB_SAMPLES_CHANNEL_OFFSET))/
-                    (M_PI*(k - (desc->delays[l]*desc->sampling_rate) - NB_SAMPLES_CHANNEL_OFFSET));
+                s = sin(M_PI*(k - (desc->delays[l]*desc->sampling_rate) - desc->channel_offset))/
+                    (M_PI*(k - (desc->delays[l]*desc->sampling_rate) - desc->channel_offset));
 
               desc->ch[aarx+(aatx*desc->nb_rx)][k].x += s*desc->a[l][aarx+(aatx*desc->nb_rx)].x;
               desc->ch[aarx+(aatx*desc->nb_rx)][k].y += s*desc->a[l][aarx+(aatx*desc->nb_rx)].y;
@@ -1436,7 +1482,7 @@ int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) {
 
   return (0);
 }
-
+   
 double N_RB2sampling_rate(uint16_t N_RB) {
   double sampling_rate;
 
@@ -1488,22 +1534,125 @@ double N_RB2channel_bandwidth(uint16_t N_RB) {
       LOG_E(PHY,"Unknown N_PRB\n");
       return(-1);
   }
-
   return(channel_bandwidth);
+}   
+
+     
+static int channelmod_print_help(char *buff, int debug, telnet_printfunc_t prnt ) {
+	prnt("channelmod commands can be used to display or modify channel models parameters\n");
+	prnt("channelmod show predef: display predefined model algorithms available in oai\n");
+	prnt("channelmod show current: display the currently used models in the running executable\n");
+	prnt("channelmod modify <model index> <param name> <param value>: set the specified parameters in a current model to the given value\n");
+	prnt("                  <model index> specifies the model, the show current model command can be used to list the current models indexes\n");
+	prnt("                  <param name> can be one of \"riceanf\", \"aoa\", \"randaoa\", \"ploss\", \"offset\", \"forgetf\"\n");
+    return CMDSTATUS_FOUND;
 }
 
+
+static void display_channelmodel(channel_desc_t *cd,int debug, telnet_printfunc_t prnt) {
+	char *module_id_str[]=MODULEID_STR_INIT;
+	if (cd->module_id != 0) {
+		prnt("model owner: %s\n",module_id_str[cd->module_id]);
+	}
+	prnt("nb_tx: %i    nb_rx: %i    taps: %i bandwidth: %lf    sampling: %lf\n",cd->nb_tx, cd->nb_rx, cd->nb_taps, cd->channel_bandwidth, cd->sampling_rate);
+	prnt("channel length: %i    Max path delay: %lf   ricean fact.: %lf    angle of arrival: %lf (randomized:%s)\n",
+		 cd->channel_length, cd->Td, cd->ricean_factor, cd->aoa, (cd->random_aoa?"Yes":"No"));
+	prnt("max Doppler: %lf    path loss: %lf   rchannel offset: %i    forget factor; %lf\n",
+		 cd->max_Doppler, cd->path_loss_dB, cd->channel_offset, cd->forgetting_factor);	
+	prnt("Initial phase: %lf   nb_path: %i \n",
+		 cd->ip, cd->nb_paths);		
+	for (int i=0; i<cd->nb_taps ; i++) {
+		prnt("taps: %i   lin. ampli. : %lf    delay: %lf \n",i,cd->amps[i], cd->delays[i]);
+	}                         
+}
+   
+  
 static int channelmod_show_cmd(char *buff, int debug, telnet_printfunc_t prnt) {
-  for(int i=0; channelmod_names[i].name != NULL ; i++) {
-    prnt("  %i %s\n", i, map_int_to_str(channelmod_names,i ));
-  }
+  char *subcmd=NULL; 
+  int s = sscanf(buff,"%ms\n",&subcmd);
 
-  return 0;
+  if (s>0) {
+    if ( strcmp(subcmd,"predef") == 0) {
+      for (int i=0; channelmod_names[i].name != NULL ; i++) {
+        prnt("  %i %s\n", i, map_int_to_str(channelmod_names,i ));
+    } 
+    } else if ( strcmp(subcmd,"current") == 0) {
+      for (int i=0; i < max_chan ; i++) {
+      	if (defined_channels[i] != NULL) {
+      	  prnt("model %i %s: \n----------------\n", i, map_int_to_str(channelmod_names,defined_channels[i]->modelid));
+          display_channelmodel(defined_channels[i],debug,prnt); 
+        }
+      }
+    } else {
+    	channelmod_print_help(buff, debug, prnt);
+    }
+  free(subcmd);
+  }
+  return CMDSTATUS_FOUND;
 }
 
-int modelid_fromname(char *modelname) {
-  int modelid=map_str_to_int(channelmod_names,modelname);
-  AssertFatal(modelid>0,
-              "random_channel.c: Error channel model %s unknown\n",modelname);
+      
+
+static int channelmod_modify_cmd(char *buff, int debug, telnet_printfunc_t prnt) {
+  char *param=NULL, *value=NULL; 
+  int cd_id= -1;
+  int s = sscanf(buff,"%i %ms %ms \n",&cd_id,&param, &value);
+  if (cd_id<0 || cd_id >= max_chan) {
+  	  prnt("ERROR, %i: Channel model id outof range (0-%i)\n",cd_id,max_chan-1);
+  	  return CMDSTATUS_FOUND;
+  }
+  if (defined_channels[cd_id]==NULL) {
+  	  prnt("ERROR, %i: Channel model has not been set\n",cd_id);
+  	  return CMDSTATUS_FOUND;
+  }  
+  
+  if (s==3) {
+    if ( strcmp(param,"riceanf") == 0) {
+        double dbl = atof(value);
+        if (dbl <0 || dbl > 1)
+        	prnt("ERROR: ricean factor range: 0 to 1, %lf is outof range\n",dbl);
+        else
+        	defined_channels[cd_id]->ricean_factor=dbl;
+    } else if ( strcmp(param,"aoa") == 0) {
+        double dbl = atof(value);
+        if (dbl <0 || dbl >6.28)
+        	prnt("ERROR: angle of arrival range: 0 to 2*Pi,  %lf is outof range\n",dbl);
+        else
+        	defined_channels[cd_id]->aoa=dbl;    
+    } else if ( strcmp(param,"randaoa") == 0) {
+        int i = atoi(value);
+        if (i!=0 && i!=1)
+        	prnt("ERROR: randaoa is a boolean, must be 0 or 1\n");
+        else
+        	defined_channels[cd_id]->random_aoa=i;
+    } else if ( strcmp(param,"ploss") == 0) {
+        double dbl = atof(value);
+        defined_channels[cd_id]->path_loss_dB=dbl;     
+    } else if ( strcmp(param,"offset") == 0) {
+        int i = atoi(value);
+        defined_channels[cd_id]->channel_offset=i;     
+    } else if ( strcmp(param,"forgetf") == 0) {
+        double dbl = atof(value);
+        if (dbl <0 || dbl > 1)
+        	prnt("ERROR: forgetting factor range: 0 to 1 (disable variation), %lf is outof range\n",dbl);
+        else
+        	defined_channels[cd_id]->forgetting_factor=dbl;     
+    } else {
+         prnt("ERROR: %s, unknown channel parameter\n",param);
+         return CMDSTATUS_FOUND;  
+    }
+  display_channelmodel(defined_channels[cd_id],debug,prnt);  
+  free(param);   
+  free(value);
+  random_channel(defined_channels[cd_id],false);                 
+  }
+  return CMDSTATUS_FOUND;           
+}
+   
+int modelid_fromname(char *modelname) {                                             
+  int modelid=map_str_to_int(channelmod_names,modelname);   
+  if (modelid < 0)   
+    LOG_E(OCM,"random_channel.c: Error channel model %s unknown\n",modelname);
   return modelid;
 }
 
@@ -1519,6 +1668,9 @@ void init_channelmod(void) {
   paramdef_t channelmod_params[] = CHANNELMOD_PARAMS_DESC;
   int ret = config_get( channelmod_params,sizeof(channelmod_params)/sizeof(paramdef_t),CHANNELMOD_SECTION);
   AssertFatal(ret >= 0, "configuration couldn't be performed");
+    defined_channels=calloc(max_chan,sizeof( channel_desc_t*));
+  AssertFatal(defined_channels!=NULL, "couldn't allocate %u channel descriptors\n",max_chan);
+  
   /* look for telnet server, if it is loaded, add the channel modeling commands to it */
   add_telnetcmd_func_t addcmd = (add_telnetcmd_func_t)get_shlibmodule_fptr("telnetsrv", TELNET_ADDCMD_FNAME);
 

openair1/SIMULATION/TOOLS/sim.h

@@ -40,6 +40,16 @@ The present clause specifies several numerical functions for testing of digital
 
 #define NB_SAMPLES_CHANNEL_OFFSET 4
 
+typedef enum {
+  UNSPECIFIED_MODID=0,
+  RFSIMU_MODULEID=1
+} channelmod_moduleid_t;
+#define MODULEID_STR_INIT {"","rfsimulator"}
+
+#define CHANMODEL_FREE_DELAY       1<<0
+#define CHANMODEL_FREE_RSQRT_6     1<<1
+#define CHANMODEL_FREE_RSQRT_NTAPS 1<<2
+#define CHANMODEL_FREE_AMPS        1<<3
 typedef struct {
   ///Number of tx antennas
   uint8_t nb_tx;
@@ -92,6 +102,14 @@ typedef struct {
   time_stats_t interp_time;
   time_stats_t interp_freq;
   time_stats_t convolution;
+  /// index in the channel descriptors array
+  unsigned int chan_idx;
+  /// id of the channel modeling algorithm
+  int modelid;
+  /// identifies channel descriptor owner (the module which created this descriptor)
+  channelmod_moduleid_t module_id;
+  /// flags to properly trigger memory free
+  unsigned int free_flags;
 } channel_desc_t;
 
 typedef struct {
@@ -214,8 +232,9 @@ typedef enum {
 #define CONFIG_HLP_SNR     "Set average SNR in dB (for --siml1 option)\n"
 #define CHANNELMOD_SECTION "channelmod"
 #define CHANNELMOD_PARAMS_DESC {  \
-    {"s"      , CONFIG_HLP_SNR, PARAMFLAG_CMDLINE_NOPREFIXENABLED, dblptr:&snr_dB , defdblval:25, TYPE_DOUBLE, 0},\
-    {"sinr_dB", NULL          , 0                                , dblptr:&sinr_dB, defdblval:0 , TYPE_DOUBLE, 0},\
+    {"s"      , CONFIG_HLP_SNR,         PARAMFLAG_CMDLINE_NOPREFIXENABLED, dblptr:&snr_dB,    defdblval:25, TYPE_DOUBLE, 0},\
+    {"sinr_dB", NULL,                   0                                , dblptr:&sinr_dB,   defdblval:0 , TYPE_DOUBLE, 0},\
+    {"max_chan, CONFIG_HLP_MAX_CHAN",   0,                                 uptr:&max_chan,    defintval:10,  TYPE_UINT,   0},\
   }
 
 #include "platform_constants.h"
@@ -273,9 +292,18 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
                                      double forgetting_factor,
                                      int32_t channel_offset,
                                      double path_loss_dB);
+/**
+\brief free memory allocated for a model descriptor
+\param ch points to the model, which cannot be used after calling this fuction
+*/
+void free_channel_desc_scm(channel_desc_t *ch);
 
-
-
+/**
+\brief This set the ownerid of a model descriptor, can be later used to check what module created a channel model
+\param cdesc points to the model descriptor
+\param module_id identifies the channel model. should be define as a macro in simu.h
+*/
+void set_channeldesc_owner(channel_desc_t *cdesc, channelmod_moduleid_t module_id);
 /** \fn void random_channel(channel_desc_t *desc)
 \brief This routine generates a random channel response (time domain) according to a tapped delay line model.
 \param desc Pointer to the channel descriptor