finish remove global vars for UE PBCH

openair1/PHY/NR_UE_ESTIMATION/nr_dl_channel_estimation.c

@@ -455,7 +455,7 @@ int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
 }
 }
   if (dmrss == 2)
-    scopeCopy(ue, pbchDlChEstimateTime, dl_ch_estimates_time, sizeof(struct complex16), idftsizeidx, ue->frame_parms.nb_antennas_rx);
+    UEscopeCopy(ue, pbchDlChEstimateTime, (void*)dl_ch_estimates_time, sizeof(struct complex16), ue->frame_parms.nb_antennas_rx, idftsizeidx);
   return(0);
 }
 

openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync.c

@@ -153,7 +153,8 @@ int nr_pbch_detection(UE_nr_rxtx_proc_t * proc, PHY_VARS_NR_UE *ue, int pbch_ini
     struct complex16 dl_ch_estimates[frame_parms->nb_antennas_rx][estimateSz];
     struct complex16 dl_ch_estimates_time[frame_parms->nb_antennas_rx][estimateSz];
     for(int i=pbch_initial_symbol; i<pbch_initial_symbol+3;i++)
-      nr_pbch_channel_estimation(ue,estimateSz, dl_ch_estimates, dl_ch_estimates_time, proc,0,0,i,i-pbch_initial_symbol,temp_ptr->i_ssb,temp_ptr->n_hf);
+      nr_pbch_channel_estimation(ue,estimateSz, dl_ch_estimates, dl_ch_estimates_time, 
+                                 proc,0,0,i,i-pbch_initial_symbol,temp_ptr->i_ssb,temp_ptr->n_hf);
     stop_meas(&ue->dlsch_channel_estimation_stats);
     fapiPbch_t result;
     ret = nr_rx_pbch(ue,

openair1/PHY/NR_UE_TRANSPORT/nr_pbch.c

@@ -37,6 +37,7 @@
 #include "PHY/INIT/phy_init.h"
 #include "openair1/SCHED_NR_UE/defs.h"
 #include <openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h>
+#include <openair1/PHY/TOOLS/phy_scope_interface.h>
 
 //#define DEBUG_PBCH
 //#define DEBUG_PBCH_ENCODING
@@ -58,7 +59,6 @@ static uint16_t nr_pbch_extract(int **rxdataF,
   uint16_t rb;
   uint8_t i,j,aarx;
   int nushiftmod4 = frame_parms->nushift;
-
   AssertFatal(symbol>=1 && symbol<5,
               "symbol %d illegal for PBCH extraction\n",
               symbol);
@@ -66,7 +66,6 @@ static uint16_t nr_pbch_extract(int **rxdataF,
   for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
     unsigned int rx_offset = frame_parms->first_carrier_offset + frame_parms->ssb_start_subcarrier;
     rx_offset = (rx_offset)%(frame_parms->ofdm_symbol_size);
-
     struct complex16 *rxF        = (struct complex16 *)&rxdataF[aarx][(symbol+s_offset)*frame_parms->ofdm_symbol_size];
     struct complex16 *rxF_ext    = rxdataF_ext[aarx];
 #ifdef DEBUG_PBCH
@@ -134,6 +133,7 @@ static uint16_t nr_pbch_extract(int **rxdataF,
         }
       }
     }
+
     struct complex16 *dl_ch0 = &dl_ch_estimates[aarx][((symbol+s_offset)*(frame_parms->ofdm_symbol_size))];
 
     //printf("dl_ch0 addr %p\n",dl_ch0);
@@ -390,15 +390,13 @@ static void nr_pbch_unscrambling(NR_UE_PBCH *pbch,
 static void nr_pbch_quantize(int16_t *pbch_llr8,
                              int16_t *pbch_llr,
                              uint16_t len) {
-  uint16_t i;
+  for (int i=0; i<len; i++) {
-
-  for (i=0; i<len; i++) {
     if (pbch_llr[i]>31)
       pbch_llr8[i]=32;
     else if (pbch_llr[i]<-31)
       pbch_llr8[i]=-32;
     else
-      pbch_llr8[i] = (char)(pbch_llr[i]);
+      pbch_llr8[i]=pbch_llr[i];
   }
 }
 /*
@@ -418,7 +416,6 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
                 uint8_t i_ssb,
                 MIMO_mode_t mimo_mode,
                 fapiPbch_t *result) {
-
   NR_UE_COMMON *nr_ue_common_vars = &ue->common_vars;
   int max_h=0;
   int symbol;
@@ -436,8 +433,8 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
   //time_stats_t path_metric,sorting,update_LLR;
   // FT ?? cppcheck fix  memset(&pbch_a[0], 0, sizeof(uint8_t) * NR_POLAR_PBCH_PAYLOAD_BITS);
   //printf("nr_pbch_ue nid_cell %d\n",frame_parms->Nid_cell);
-
   int16_t pbch_e_rx[960]= {0}; //Fixme: previous version erase only NR_POLAR_PBCH_E bytes
+  int16_t pbch_unClipped[960]= {0};
   int pbch_e_rx_idx=0;
   int symbol_offset=1;
 
@@ -446,22 +443,20 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
   else
     symbol_offset=0;
 
-
 #ifdef DEBUG_PBCH
   //printf("address dataf %p",nr_ue_common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF);
   write_output("rxdataF0_pbch.m","rxF0pbch",
                &nr_ue_common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[0][(symbol_offset+1)*frame_parms->ofdm_symbol_size],frame_parms->ofdm_symbol_size*3,1,1);
 #endif
-
   // symbol refers to symbol within SSB. symbol_offset is the offset of the SSB wrt start of slot
   double log2_maxh;
+
   for (symbol=1; symbol<4; symbol++) {
     const uint16_t nb_re=symbol == 2 ? 72 : 180;
     struct complex16 rxdataF_ext[frame_parms->nb_antennas_rx][20*12*4];
     struct complex16 rxdataF_comp[frame_parms->nb_antennas_rx][nb_re];
     //was dl_ch_estimates[idx]     = (int32_t *)malloc16_clear( sizeof(int32_t)*7*2*sizeof(int)*(fp->ofdm_symbol_size) );
     struct complex16 dl_ch_estimates_ext[frame_parms->nb_antennas_rx][20*12*4];
-    
     nr_pbch_extract(nr_ue_common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF,
                     estimateSz,
                     dl_ch_estimates,
@@ -510,15 +505,20 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
       nr_pbch_quantize(pbch_e_rx+pbch_e_rx_idx,
                        (short *)rxdataF_comp[0],
                        144);
+      memcpy(pbch_unClipped+pbch_e_rx_idx, rxdataF_comp[0], 144*sizeof(int16_t));
       pbch_e_rx_idx+=144;
     } else {
       nr_pbch_quantize(pbch_e_rx+pbch_e_rx_idx,
                        (short *)rxdataF_comp[0],
                        360);
+      memcpy(pbch_unClipped+pbch_e_rx_idx, rxdataF_comp[0], 144*sizeof(int16_t));
       pbch_e_rx_idx+=360;
     }
   }
 
+  // legacy code use int16, but it is complex16
+  UEscopeCopy(ue, pbchRxdataF_comp, pbch_unClipped, sizeof(struct complex16), frame_parms->nb_antennas_rx, pbch_e_rx_idx/2);
+  UEscopeCopy(ue, pbchLlr, pbch_e_rx, sizeof(int16_t), frame_parms->nb_antennas_rx, pbch_e_rx_idx);
 #ifdef DEBUG_PBCH
   write_output("rxdataF_comp.m","rxFcomp",rxdataF_comp[0],240*3,1,1);
 #endif
@@ -578,23 +578,24 @@ nr_pbch_unscrambling(nr_ue_pbch_vars,pbch_e_rx,frame_parms->Nid_cell,nushift,M,N
 result->decoded_output[i] = (uint8_t)((payload>>((3-i)<<3))&0xff);
 
   frame_parms->half_frame_bit = (result->xtra_byte>>4)&0x01; // computing the half frame index from the extra byte
-
   frame_parms->ssb_index = i_ssb;  // ssb index corresponds to i_ssb for Lmax = 4,8
+
   if (Lmax == 64) {   // for Lmax = 64 ssb index 4th,5th and 6th bits are in extra byte
   for (int i=0; i<3; i++)
       frame_parms->ssb_index += (((result->xtra_byte>>(7-i))&0x01)<<(3+i));
   }
 
   ue->symbol_offset = nr_get_ssb_start_symbol(frame_parms,frame_parms->ssb_index);
+
   if (frame_parms->half_frame_bit)
   ue->symbol_offset += (frame_parms->slots_per_frame>>1)*frame_parms->symbols_per_slot;
 
   uint8_t frame_number_4lsb = 0;
+
   for (int i=0; i<4; i++)
 frame_number_4lsb |= ((result->xtra_byte>>i)&1)<<(3-i);
 
   proc->decoded_frame_rx = frame_number_4lsb;
-
 #ifdef DEBUG_PBCH
   printf("xtra_byte %x payload %x\n", xtra_byte, payload);
 
@@ -602,14 +603,12 @@ frame_parms->half_frame_bit = (result->xtra_byte>>4)&0x01; // computing the half
     //     printf("unscrambling pbch_a[%d] = %x \n", i,pbch_a[i]);
     printf("[PBCH] decoder payload[%d] = %x\n",i,result->decoded_output[i]);
   }
-#endif
 
+#endif
   nr_downlink_indication_t dl_indication;
   fapi_nr_rx_indication_t *rx_ind = calloc(1, sizeof(*rx_ind));
   uint16_t number_pdus = 1;
-
   nr_fill_dl_indication(&dl_indication, NULL, rx_ind, proc, ue, gNB_id);
-
   nr_fill_rx_indication(rx_ind, FAPI_NR_RX_PDU_TYPE_SSB, gNB_id, ue, NULL, NULL, number_pdus, proc,(void *)result);
 
   if (ue->if_inst && ue->if_inst->dl_indication)

openair1/PHY/TOOLS/nr_phy_scope.c

@@ -41,6 +41,10 @@ typedef struct complex16 scopeSample_t;
 #define SquaredNorm(VaR) ((VaR).r*(VaR).r+(VaR).i*(VaR).i)
 
 typedef struct {
+  int dataSize;
+  int elementSz;
+  int colSz;
+  int lineSz;
 } scopeGraphData_t;
 
 typedef struct OAIgraph {
@@ -585,9 +589,10 @@ static void ueChannelResponse  (scopeGraphData_t **data, OAIgraph_t *graph, PHY_
   if (!data[pbchDlChEstimateTime])
     return;
 
-  genericPowerPerAntena(graph, phy_vars_ue->frame_parms.nb_antennas_rx,
+  const scopeSample_t *tmp=(scopeSample_t *)(data[pbchDlChEstimateTime]+1);
-                        (const scopeSample_t **) &data[pbchDlChEstimateTime],
+  genericPowerPerAntena(graph, data[pbchDlChEstimateTime]->colSz,
-                        phy_vars_ue->frame_parms.ofdm_symbol_size>>3);
+                        &tmp,
+                        data[pbchDlChEstimateTime]->lineSz);
 }
 
 static void ueFreqWaterFall (scopeGraphData_t **data, OAIgraph_t *graph,PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id ) {
@@ -639,51 +644,38 @@ static void uePbchLLR  (scopeGraphData_t **data, OAIgraph_t *graph, PHY_VARS_NR_
   if ( !data[pbchLlr])
     return;
 
-  int16_t *pbch_llr = (int16_t *)data[pbchLlr];
+  const int sz=data[pbchLlr]->lineSz;
+  //const int antennas=data[pbchLlr]->colSz;
+  // We take the first antenna only for now
+  int16_t *llrs = (int16_t *) (data[pbchLlr]+1);
   float *llr_pbch, *bit_pbch;
-  oai_xygraph_getbuff(graph, &bit_pbch, &llr_pbch, 864, 0);
+  oai_xygraph_getbuff(graph, &bit_pbch, &llr_pbch, sz, 0);
 
-  for (int i=0; i<864; i++) {
+  for (int i=0; i<sz; i++) {
-    llr_pbch[i] = (float) pbch_llr[i];
+    llr_pbch[i] = llrs[i];
   }
 
-  oai_xygraph(graph,bit_pbch,llr_pbch,864,0,10);
+  oai_xygraph(graph,bit_pbch,llr_pbch,sz,0,10);
 }
+
 static void uePbchIQ  (scopeGraphData_t **data, OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
   // PBCH I/Q of MF Output
-
   if (!data[pbchRxdataF_comp])
     return;
 
-  scopeSample_t *pbch_comp = (scopeSample_t *) data[pbchRxdataF_comp];
+  scopeSample_t *pbch_comp = (scopeSample_t *) (data[pbchRxdataF_comp]+1);
+  const int sz=data[pbchRxdataF_comp]->lineSz;
   float *I, *Q;
-  oai_xygraph_getbuff(graph, &I, &Q, 180*3, 0);
+  oai_xygraph_getbuff(graph, &I, &Q, sz, 0);
-  memset(I,0,180*3*sizeof(*I));
-  memset(Q,0,180*3*sizeof(*Q));
-  int first_symbol=1;
-  int base=0;
 
-  for (int symbol=first_symbol; symbol<(first_symbol+3); symbol++) {
+  for (int i=0; i<sz; i++) {
-    int nb_re;
+    I[i]=pbch_comp[i].r;
-
+    Q[i]=pbch_comp[i].i;
-    if (symbol == 2 || symbol == 6)
-      nb_re = 72;
-    else
-      nb_re = 180;
-
-    AssertFatal(base+nb_re<180*3,"");
-
-    for (int i=0; i<nb_re; i++) {
-      I[base+i] = pbch_comp[symbol*20*12+i].r;
-      Q[base+i] = pbch_comp[symbol*20*12+i].i;
   }
 
-    base+=nb_re;
+  oai_xygraph(graph, I, Q, sz, 0, true);
 }
 
-  AssertFatal(base <= 180*3,"");
-  oai_xygraph(graph,I,Q,base,0, 10);
-}
 static void uePcchLLR  (scopeGraphData_t **data, OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
   // PDCCH LLRs
   if (!phy_vars_ue->pdcch_vars[0][eNB_id]->llr)
@@ -916,12 +908,11 @@ static void *nrUEscopeThread(void *arg) {
   char *name="5G-UE-scope";
   fl_initialize (&fl_argc, &name, NULL, 0, 0);
   OAI_phy_scope_t  *form_nrue=create_phy_scope_nrue(0);
-
+  (( scopeData_t *)ue->scopeData)->liveData=calloc(sizeof(scopeGraphData_t *), UEdataTypeNumberOfItems);
-  scopeGraphData_t *UEliveData[UEdataTypeNumberOfItems];
 
   while (!oai_exit) {
     fl_freeze_form(form_nrue->phy_scope);
-    phy_scope_nrUE(UEliveData,
+    phy_scope_nrUE((( scopeData_t *)ue->scopeData)->liveData,
                    form_nrue,
                    ue,
                    0,0);
@@ -933,8 +924,30 @@ static void *nrUEscopeThread(void *arg) {
   pthread_exit((void *)arg);
 }
 
-void UEcopyData(enum UEdataType type, void * data, int elementSz, int colSz, int lineSz) {
+void UEcopyData(PHY_VARS_NR_UE *ue, enum UEdataType type, void *dataIn, int elementSz, int colSz, int lineSz) {
+  scopeData_t *tmp=(scopeData_t *)ue->scopeData;
 
+  if (tmp) {
+    scopeGraphData_t *live= ((scopeGraphData_t **)tmp->liveData)[type];
+
+    if (live == NULL || live->dataSize < elementSz*colSz*lineSz) {
+      scopeGraphData_t *ptr=realloc(live, sizeof(scopeGraphData_t) + elementSz*colSz*lineSz);
+
+      if (!ptr) {
+        LOG_E(PHY,"can't realloc\n");
+        return;
+      } else {
+        live=ptr;
+      }
+    }
+
+    live->dataSize=elementSz*colSz*lineSz;
+    live->elementSz=elementSz;
+    live->colSz=colSz;
+    live->lineSz=lineSz;
+    memcpy(live+1, dataIn,  elementSz*colSz*lineSz);
+    ((scopeGraphData_t **)tmp->liveData)[type]=live;
+  }
 }
 
 void nrUEinitScope(PHY_VARS_NR_UE *ue) {

openair1/PHY/TOOLS/phy_scope_interface.h

@@ -32,6 +32,7 @@
 #ifndef __PHY_SCOPE_INTERFACE_H__
 #define __PHY_SCOPE_INTERFACE_H__
 #include <openair1/PHY/defs_gNB.h>
+#include <openair1/PHY/defs_nr_UE.h>
 
 typedef struct {
   int *argc;
@@ -54,11 +55,11 @@ typedef struct scopeData_s {
   PHY_VARS_gNB *gNB;
   void *liveData;
   void (*slotFunc)(int32_t *data, int slot,  void *scopeData);
-  void (*copyData)(enum UEdataType, void * data, int elementSz, int colSz, int lineSz);
+  void (*copyData)(PHY_VARS_NR_UE *,enum UEdataType, void *data, int elementSz, int colSz, int lineSz);
 } scopeData_t;
 
 int load_softscope(char *exectype, void *initarg);
 int end_forms(void) ;
 
-#define scopeCopy(ue, type, ...) if(ue->scopeData) ((scopeData_t*)ue->scopeData)->copyData(type, ##__VA_ARGS__);
+#define UEscopeCopy(ue, type, ...) if(ue->scopeData) ((scopeData_t*)ue->scopeData)->copyData(ue, type, ##__VA_ARGS__);
 #endif

openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c

@@ -1170,7 +1170,7 @@ int nr_ue_dl_indication(nr_downlink_indication_t *dl_info, NR_UL_TIME_ALIGNMENT_
                                          (dl_info->rx_ind->rx_indication_body+i)->ssb_pdu.ssb_length,
                                          (dl_info->rx_ind->rx_indication_body+i)->ssb_pdu.ssb_start_subcarrier,
                                          (dl_info->rx_ind->rx_indication_body+i)->ssb_pdu.cell_id)) << FAPI_NR_RX_PDU_TYPE_SSB;
-
+	    free((dl_info->rx_ind->rx_indication_body+i)->ssb_pdu.pdu);
             break;
           case FAPI_NR_RX_PDU_TYPE_SIB:
             ret_mask |= (handle_bcch_dlsch(dl_info->module_id,