remove-NR_UE_PBCH scope to finish

openair1/PHY/INIT/nr_init_ue.c

@@ -416,29 +416,10 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
       }
 
       // PBCH
-      pbch_vars[gNB_id]->rxdataF_ext         = (int32_t **)malloc16( fp->nb_antennas_rx*sizeof(int32_t *) );
-      pbch_vars[gNB_id]->rxdataF_comp        = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
-      pbch_vars[gNB_id]->dl_ch_estimates     = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
-      pbch_vars[gNB_id]->dl_ch_estimates_ext = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
-      pbch_vars[gNB_id]->dl_ch_estimates_time = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
-      pbch_vars[gNB_id]->llr                 = (int16_t *)malloc16_clear( 1920 ); //
       prach_vars[gNB_id]->prachF             = (int16_t *)malloc16_clear( sizeof(int)*(7*2*sizeof(int)*(fp->ofdm_symbol_size*12)) );
       prach_vars[gNB_id]->prach              = (int16_t *)malloc16_clear( sizeof(int)*(7*2*sizeof(int)*(fp->ofdm_symbol_size*12)) );
 
-      for (i=0; i<fp->nb_antennas_rx; i++) {
-        pbch_vars[gNB_id]->rxdataF_ext[i]    = (int32_t *)malloc16_clear( sizeof(int32_t)*20*12*4 );
-
-        for (j=0; j<4; j++) {//fp->nb_antennas_tx;j++) {
-          int idx = (j*fp->nb_antennas_rx)+i;
-          pbch_vars[gNB_id]->rxdataF_comp[idx]        = (int32_t *)malloc16_clear( sizeof(int32_t)*20*12*4 );
-          pbch_vars[gNB_id]->dl_ch_estimates[idx]     = (int32_t *)malloc16_clear( sizeof(int32_t)*7*2*sizeof(int)*(fp->ofdm_symbol_size) );
-          pbch_vars[gNB_id]->dl_ch_estimates_time[idx]= (int32_t *)malloc16_clear( sizeof(int32_t)*7*2*sizeof(int)*(fp->ofdm_symbol_size) );
-          pbch_vars[gNB_id]->dl_ch_estimates_ext[idx] = (int32_t *)malloc16_clear( sizeof(int32_t)*20*12*4 );
-        }
-      }
     }
-
-    pbch_vars[gNB_id]->decoded_output = (uint8_t *)malloc16_clear(64);
   }
 
   // initialization for the last instance of pdsch_vars (used for MU-MIMO)

openair1/PHY/NR_UE_ESTIMATION/nr_adjust_synch_ue.c

@@ -36,6 +36,7 @@
 void nr_adjust_synch_ue(NR_DL_FRAME_PARMS *frame_parms,
                         PHY_VARS_NR_UE *ue,
                         module_id_t gNB_id,
+			const int estimateSz, struct complex16 dl_ch_estimates_time[][estimateSz],
                         uint8_t frame,
                         uint8_t subframe,
                         unsigned char clear,
@@ -60,8 +61,8 @@ void nr_adjust_synch_ue(NR_DL_FRAME_PARMS *frame_parms,
 
     int j = (i < 0) ? (i + frame_parms->ofdm_symbol_size) : i;
     for (int aa = 0; aa < frame_parms->nb_antennas_rx; aa++) {
-      int Re = ((int16_t*)ue->pbch_vars[gNB_id]->dl_ch_estimates_time[aa])[(j<<1)];
-      int Im = ((int16_t*)ue->pbch_vars[gNB_id]->dl_ch_estimates_time[aa])[1+(j<<1)];
+      int Re = dl_ch_estimates_time[aa][j].r;
+      int Im = dl_ch_estimates_time[aa][j].i;
       temp += (Re*Re/2) + (Im*Im/2);
     }
 

openair1/PHY/NR_UE_ESTIMATION/nr_dl_channel_estimation.c

@@ -29,6 +29,7 @@
 #include "PHY/NR_REFSIG/ptrs_nr.h"
 #include "PHY/NR_TRANSPORT/nr_sch_dmrs.h"
 #include "filt16a_32.h"
+#include <openair1/PHY/TOOLS/phy_scope_interface.h>
 
 //#define DEBUG_PDSCH
 //#define DEBUG_PDCCH
@@ -43,7 +44,6 @@ int nr_pbch_dmrs_correlation(PHY_VARS_NR_UE *ue,
                              NR_UE_SSB *current_ssb)
 {
   int pilot[200] __attribute__((aligned(16)));
-  unsigned char aarx;
   unsigned short k;
   unsigned int pilot_cnt;
   int16_t ch[2],*pil,*rxF;
@@ -77,7 +77,7 @@ int nr_pbch_dmrs_correlation(PHY_VARS_NR_UE *ue,
   // generate pilot
   nr_pbch_dmrs_rx(dmrss,ue->nr_gold_pbch[n_hf][ssb_index], &pilot[0]);
 
-  for (aarx=0; aarx<ue->frame_parms.nb_antennas_rx; aarx++) {
+  for (int aarx=0; aarx<ue->frame_parms.nb_antennas_rx; aarx++) {
 
     int re_offset = ssb_offset;
     pil   = (int16_t *)&pilot[0];
@@ -197,6 +197,9 @@ int nr_pbch_dmrs_correlation(PHY_VARS_NR_UE *ue,
 
 
 int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
+			       int estimateSz,
+			       struct complex16 dl_ch_estimates [][estimateSz],
+			       struct complex16 dl_ch_estimates_time [][estimateSz],
                                UE_nr_rxtx_proc_t *proc,
                                uint8_t gNB_id,
                                unsigned char Ns,
@@ -206,16 +209,14 @@ int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
                                uint8_t n_hf)
 {
   int pilot[200] __attribute__((aligned(16)));
-  unsigned char aarx,p;
   unsigned short k;
   unsigned int pilot_cnt;
-  int16_t ch[2],*pil,*rxF,*dl_ch,*fl,*fm,*fr;
+  int16_t *pil,*rxF,*dl_ch,*fl,*fm,*fr;
   int ch_offset,symbol_offset;
   //int slot_pbch;
 
   uint8_t nushift;
-  int **dl_ch_estimates  =ue->pbch_vars[gNB_id]->dl_ch_estimates;
-  int **rxdataF=ue->common_vars.common_vars_rx_data_per_thread[proc->thread_id].rxdataF;
+   int **rxdataF=ue->common_vars.common_vars_rx_data_per_thread[proc->thread_id].rxdataF;
 
   nushift =  ue->frame_parms.Nid_cell%4;
   ue->frame_parms.nushift = nushift;
@@ -269,17 +270,57 @@ int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
     break;
   }
 
+  idft_size_idx_t idftsizeidx;
+  
+  switch (ue->frame_parms.ofdm_symbol_size) {
+  case 128:
+    idftsizeidx = IDFT_128;
+    break;
+    
+  case 256:
+    idftsizeidx = IDFT_256;
+    break;
+    
+  case 512:
+    idftsizeidx = IDFT_512;
+    break;
+    
+  case 1024:
+    idftsizeidx = IDFT_1024;
+    break;
+    
+  case 1536:
+    idftsizeidx = IDFT_1536;
+    break;
+    
+  case 2048:
+    idftsizeidx = IDFT_2048;
+    break;
+    
+  case 3072:
+    idftsizeidx = IDFT_3072;
+    break;
+    
+  case 4096:
+    idftsizeidx = IDFT_4096;
+    break;
+    
+  default:
+    printf("unsupported ofdm symbol size \n");
+    assert(0);
+  }
+  
   // generate pilot
   nr_pbch_dmrs_rx(dmrss,ue->nr_gold_pbch[n_hf][ssb_index], &pilot[0]);
 
-  for (aarx=0; aarx<ue->frame_parms.nb_antennas_rx; aarx++) {
+  for (int aarx=0; aarx<ue->frame_parms.nb_antennas_rx; aarx++) {
 
     int re_offset = ssb_offset;
     pil   = (int16_t *)&pilot[0];
     rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
     dl_ch = (int16_t *)&dl_ch_estimates[aarx][ch_offset];
 
-    memset(dl_ch,0,4*(ue->frame_parms.ofdm_symbol_size));
+    memset(dl_ch,0,sizeof(*dl_ch)*(ue->frame_parms.ofdm_symbol_size));
 
 #ifdef DEBUG_CH
     printf("pbch ch est pilot addr %p RB_DL %d\n",&pilot[0], ue->frame_parms.N_RB_DL);
@@ -289,6 +330,7 @@ int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
 #endif
 
     // Treat first 2 pilots specially (left edge)
+    int16_t ch[2];
     ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
     ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
 
@@ -402,62 +444,18 @@ int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
 
     }
 
-    idft_size_idx_t idftsizeidx;
-
-    switch (ue->frame_parms.ofdm_symbol_size) {
-    case 128:
-      idftsizeidx = IDFT_128;
-      break;
-
-    case 256:
-      idftsizeidx = IDFT_256;
-      break;
-
-    case 512:
-      idftsizeidx = IDFT_512;
-      break;
-
-    case 1024:
-      idftsizeidx = IDFT_1024;
-      break;
-
-    case 1536:
-      idftsizeidx = IDFT_1536;
-      break;
-
-    case 2048:
-      idftsizeidx = IDFT_2048;
-      break;
-
-    case 3072:
-      idftsizeidx = IDFT_3072;
-      break;
-
-    case 4096:
-      idftsizeidx = IDFT_4096;
-      break;
-
-    default:
-      printf("unsupported ofdm symbol size \n");
-      assert(0);
-    }
-
     if( dmrss == 2) // update time statistics for last PBCH symbol
     {
       // do ifft of channel estimate
-      for (aarx=0; aarx<ue->frame_parms.nb_antennas_rx; aarx++)
-        for (p=0; p<ue->frame_parms.nb_antenna_ports_gNB; p++) {
-          if (ue->pbch_vars[gNB_id]->dl_ch_estimates[(p*ue->frame_parms.nb_antennas_rx)+aarx])
-          {
-            LOG_D(PHY,"Channel Impulse Computation Slot %d ThreadId %d Symbol %d ch_offset %d\n", Ns, proc->thread_id, symbol, ch_offset);
-            idft(idftsizeidx,
-                 (int16_t*) &ue->pbch_vars[gNB_id]->dl_ch_estimates[(p*ue->frame_parms.nb_antennas_rx)+aarx][ch_offset],
-                 (int16_t*) ue->pbch_vars[gNB_id]->dl_ch_estimates_time[(p*ue->frame_parms.nb_antennas_rx)+aarx],1);
-          }
-        }
-    }
-
-  }
+      LOG_D(PHY,"Channel Impulse Computation Slot %d Symbol %d ch_offset %d\n", Ns, symbol, ch_offset);
+      idft(idftsizeidx,
+	   (int16_t*) &dl_ch_estimates[aarx][ch_offset],
+	   (int16_t*) dl_ch_estimates_time[aarx],
+	   1);
+}
+}
+  if (dmrss == 2)
+    scopeCopy(ue, pbchDlChEstimateTime, dl_ch_estimates_time, sizeof(struct complex16), idftsizeidx, ue->frame_parms.nb_antennas_rx);
   return(0);
 }
 

openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h

@@ -56,7 +56,10 @@ int nr_pbch_dmrs_correlation(PHY_VARS_NR_UE *ue,
                              NR_UE_SSB *current_ssb);
 
 int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
-                               UE_nr_rxtx_proc_t *proc,
+                               int estimateSz,
+			       struct complex16 dl_ch_estimates [][estimateSz],
+			       struct complex16 dl_ch_estimates_time [][estimateSz],
+			       UE_nr_rxtx_proc_t *proc,
                                uint8_t gNB_id,
                                unsigned char Ns,
                                unsigned char symbol,
@@ -78,6 +81,8 @@ int nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
 void nr_adjust_synch_ue(NR_DL_FRAME_PARMS *frame_parms,
                         PHY_VARS_NR_UE *ue,
                         module_id_t gNB_id,
+			int estimateSz,
+			struct complex16 dl_ch_estimates_time [][estimateSz],
                         uint8_t frame,
                         uint8_t subframe,
                         unsigned char clear,

openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync.c

@@ -149,17 +149,22 @@ int nr_pbch_detection(UE_nr_rxtx_proc_t * proc, PHY_VARS_NR_UE *ue, int pbch_ini
 
     start_meas(&ue->dlsch_channel_estimation_stats);
   // computing channel estimation for selected best ssb
+    const int estimateSz=7*2*sizeof(int)*frame_parms->ofdm_symbol_size;
+    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,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,
                      proc,
-                     ue->pbch_vars[0],
+                     estimateSz, dl_ch_estimates,
+		     ue->pbch_vars[0],
                      frame_parms,
                      0,
                      temp_ptr->i_ssb,
-                     SISO);
+                     SISO,
+		     &result);
 
     temp_ptr=temp_ptr->next_ssb;
   }

openair1/PHY/NR_UE_TRANSPORT/nr_pbch.c

@@ -36,6 +36,7 @@
 #include "PHY/LTE_REFSIG/lte_refsig.h"
 #include "PHY/INIT/phy_init.h"
 #include "openair1/SCHED_NR_UE/defs.h"
+#include <openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h>
 
 //#define DEBUG_PBCH 
 //#define DEBUG_PBCH_ENCODING
@@ -46,16 +47,16 @@
 
 #define print_shorts(s,x) printf("%s : %d,%d,%d,%d,%d,%d,%d,%d\n",s,((int16_t*)x)[0],((int16_t*)x)[1],((int16_t*)x)[2],((int16_t*)x)[3],((int16_t*)x)[4],((int16_t*)x)[5],((int16_t*)x)[6],((int16_t*)x)[7])
 
-uint16_t nr_pbch_extract(int **rxdataF,
-                         int **dl_ch_estimates,
-                         int **rxdataF_ext,
-                         int **dl_ch_estimates_ext,
+static uint16_t nr_pbch_extract(int **rxdataF,
+                         const int estimateSz,
+			 struct complex16 dl_ch_estimates[][estimateSz],
+                         struct complex16 rxdataF_ext[][20*12*4],
+                         struct complex16 dl_ch_estimates_ext[][20*12*4],
                          uint32_t symbol,
                          uint32_t s_offset,
                          NR_DL_FRAME_PARMS *frame_parms) {
   uint16_t rb;
   uint8_t i,j,aarx;
-  int32_t *dl_ch0,*dl_ch0_ext,*rxF,*rxF_ext;
   int nushiftmod4 = frame_parms->nushift;
 
   AssertFatal(symbol>=1 && symbol<5,
@@ -66,8 +67,8 @@ uint16_t nr_pbch_extract(int **rxdataF,
     unsigned int rx_offset = frame_parms->first_carrier_offset + frame_parms->ssb_start_subcarrier;
     rx_offset = (rx_offset)%(frame_parms->ofdm_symbol_size);
 
-    rxF        = &rxdataF[aarx][(symbol+s_offset)*frame_parms->ofdm_symbol_size];
-    rxF_ext    = &rxdataF_ext[aarx][symbol*20*12];
+    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
     printf("extract_rbs (nushift %d): rx_offset=%d, symbol %u\n",frame_parms->nushift,
            (rx_offset + ((symbol+s_offset)*(frame_parms->ofdm_symbol_size))),symbol);
@@ -76,7 +77,6 @@ uint16_t nr_pbch_extract(int **rxdataF,
     for (int i =0; i<8; i++) {
       printf("rxF [%d]= %d\n",i,rxF[i]);
       printf("pbch extract rxF  %d %d addr %p\n", p[2*i], p[2*i+1], &p[2*i]);
-      printf("rxF ext addr %p\n", &rxF_ext[i]);
     }
 
 #endif
@@ -134,11 +134,10 @@ uint16_t nr_pbch_extract(int **rxdataF,
           }
       }
     }
-
-    dl_ch0 = &dl_ch_estimates[aarx][((symbol+s_offset)*(frame_parms->ofdm_symbol_size))];
+    struct complex16 *dl_ch0 = &dl_ch_estimates[aarx][((symbol+s_offset)*(frame_parms->ofdm_symbol_size))];
 
     //printf("dl_ch0 addr %p\n",dl_ch0);
-    dl_ch0_ext = &dl_ch_estimates_ext[aarx][symbol*20*12];
+    struct complex16 *dl_ch0_ext = &dl_ch_estimates_ext[aarx][symbol*20*12];
 
     for (rb=0; rb<20; rb++) {
       j=0;
@@ -199,7 +198,7 @@ uint16_t nr_pbch_extract(int **rxdataF,
 //__m128i avg128;
 
 //compute average channel_level on each (TX,RX) antenna pair
-int nr_pbch_channel_level(int **dl_ch_estimates_ext,
+int nr_pbch_channel_level(struct complex16 dl_ch_estimates_ext[][20*12*4],
                           NR_DL_FRAME_PARMS *frame_parms,
                           uint32_t symbol) {
   int16_t rb, nb_rb=20;
@@ -258,13 +257,13 @@ int nr_pbch_channel_level(int **dl_ch_estimates_ext,
   return(avg2);
 }
 
-void nr_pbch_channel_compensation(int **rxdataF_ext,
-                                  int **dl_ch_estimates_ext,
-                                  int **rxdataF_comp,
-                                  NR_DL_FRAME_PARMS *frame_parms,
-                                  uint32_t symbol,
-                                  uint8_t output_shift) {
-  const uint16_t nb_re=symbol == 2 ? 72 : 180;
+static void nr_pbch_channel_compensation(struct complex16 rxdataF_ext[][20*12*4],
+					 struct complex16 dl_ch_estimates_ext[][20*12*4],
+					 int cols,
+					 struct complex16 rxdataF_comp[][cols],
+					 NR_DL_FRAME_PARMS *frame_parms,
+					 uint32_t symbol,
+					 uint8_t output_shift) {
   AssertFatal((symbol > 0 && symbol < 4),
               "symbol %d is illegal for PBCH DM-RS\n",
               symbol);
@@ -273,15 +272,15 @@ void nr_pbch_channel_compensation(int **rxdataF_ext,
 
   for (int aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
     vect128 *dl_ch128          = (vect128 *)&dl_ch_estimates_ext[aarx][symbol*20*12];
-    vect128 *rxdataF128        = (vect128 *)&rxdataF_ext[aarx][symbol*20*12];
-    vect128 *rxdataF_comp128   = (vect128 *)&rxdataF_comp[aarx][symbol*20*12];
+    vect128 *rxdataF128        = (vect128 *)rxdataF_ext[aarx];
+    vect128 *rxdataF_comp128   = (vect128 *)rxdataF_comp[aarx];
     /*
     printf("ch compensation dl_ch ext addr %p \n", &dl_ch_estimates_ext[aarx][symbol*20*12]);
-    printf("rxdataf ext addr %p symbol %d\n", &rxdataF_ext[aarx][symbol*20*12], symbol);
+    printf("rxdataf ext addr %p symbol %d\n", rxdataF_ext[aarx], symbol);
     printf("rxdataf_comp addr %p\n",&rxdataF_comp[aarx][symbol*20*12]);
     */
 
-    for (int re=0; re<nb_re; re+=12) {
+    for (int re=0; re<cols; re+=12) {
       *rxdataF_comp128++ = mulByConjugate128(rxdataF128++, dl_ch128++, output_shift);
       *rxdataF_comp128++ = mulByConjugate128(rxdataF128++, dl_ch128++, output_shift);
       *rxdataF_comp128++ = mulByConjugate128(rxdataF128++, dl_ch128++, output_shift);
@@ -327,16 +326,18 @@ void nr_pbch_detection_mrc(NR_DL_FRAME_PARMS *frame_parms,
 }
 
 static void nr_pbch_unscrambling(NR_UE_PBCH *pbch,
-                          uint16_t Nid,
-                          uint8_t nushift,
-                          uint16_t M,
-                          uint16_t length,
-                          uint8_t bitwise,
-                          uint32_t unscrambling_mask) {
+				 int16_t *demod_pbch_e,	 
+                                 uint16_t Nid,
+                                 uint8_t nushift,
+                                 uint16_t M,
+                                 uint16_t length,
+                                 uint8_t bitwise,
+				 uint32_t unscrambling_mask,
+				 uint32_t pbch_a_prime,
+				 uint32_t *pbch_a_interleaved) {
   uint8_t reset, offset;
   uint32_t x1, x2, s=0;
   uint8_t k=0;
-  int16_t *demod_pbch_e = pbch->llr;
   reset = 1;
   // x1 is set in first call to lte_gold_generic
   x2 = Nid; //this is c_init
@@ -361,10 +362,10 @@ static void nr_pbch_unscrambling(NR_UE_PBCH *pbch,
         reset = 0;
       }
 
-      (pbch->pbch_a_interleaved) ^= ((unscrambling_mask>>i)&1)? ((pbch->pbch_a_prime>>i)&1)<<i : (((pbch->pbch_a_prime>>i)&1) ^ ((s>>((k+offset)&0x1f))&1))<<i;
-      k += (!((unscrambling_mask>>i)&1));
+    *pbch_a_interleaved ^= ((unscrambling_mask>>i)&1)? ((pbch_a_prime>>i)&1)<<i : (((pbch_a_prime>>i)&1) ^ ((s>>((k+offset)&0x1f))&1))<<i;
+    k += (!((unscrambling_mask>>i)&1));
 #ifdef DEBUG_PBCH_ENCODING
-      printf("i %d k %d offset %d (unscrambling_mask>>i)&1) %d s: %08x\t  pbch_a_interleaved 0x%08x (!((unscrambling_mask>>i)&1)) %d\n", i, k, offset, (unscrambling_mask>>i)&1, s, pbch->pbch_a_interleaved,
+     printf("i %d k %d offset %d (unscrambling_mask>>i)&1) %d s: %08x\t  pbch_a_interleaved 0x%08x (!((unscrambling_mask>>i)&1)) %d\n", i, k, offset, (unscrambling_mask>>i)&1, s, *pbch_a_interleaved,
              (!((unscrambling_mask>>i)&1)));
 #endif
     } else {
@@ -386,7 +387,7 @@ static void nr_pbch_unscrambling(NR_UE_PBCH *pbch,
   }
 }
 
-void nr_pbch_quantize(int16_t *pbch_llr8,
+static void nr_pbch_quantize(int16_t *pbch_llr8,
                       int16_t *pbch_llr,
                       uint16_t len) {
   uint16_t i;
@@ -410,11 +411,13 @@ uint8_t pbch_deinterleaving_pattern[32] = {28,0,31,30,7,29,25,27,5,8,24,9,10,11,
 
 int nr_rx_pbch( PHY_VARS_NR_UE *ue,
                 UE_nr_rxtx_proc_t *proc,
+                int estimateSz, struct complex16 dl_ch_estimates [][estimateSz], 
                 NR_UE_PBCH *nr_ue_pbch_vars,
                 NR_DL_FRAME_PARMS *frame_parms,
                 uint8_t gNB_id,
                 uint8_t i_ssb,
-                MIMO_mode_t mimo_mode) {
+                MIMO_mode_t mimo_mode,
+		fapiPbch_t* result) {
 
   NR_UE_COMMON *nr_ue_common_vars = &ue->common_vars;
   int max_h=0;
@@ -422,9 +425,6 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
   //uint8_t pbch_a[64];
 //FT ?? cppcheck doesn't like pbch_a allocation because of line 525..and i don't get what this variable is for..
 //uint8_t *pbch_a = malloc(sizeof(uint8_t) * NR_POLAR_PBCH_PAYLOAD_BITS);
-  //uint32_t pbch_a_prime;
-  int16_t *pbch_e_rx;
-  uint8_t *decoded_output = nr_ue_pbch_vars->decoded_output;
   uint8_t nushift;
   uint16_t M;
   uint8_t Lmax=frame_parms->Lmax; 
@@ -437,9 +437,8 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
 // 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);
 
-  pbch_e_rx = &nr_ue_pbch_vars->llr[0];
-  // clear LLR buffer
-  memset(nr_ue_pbch_vars->llr,0,NR_POLAR_PBCH_E);
+  int16_t pbch_e_rx[960]={0}; //Fixme: previous version erase only NR_POLAR_PBCH_E bytes
+  int pbch_e_rx_idx=0;
   int symbol_offset=1;
 
   if (ue->is_synchronized > 0)
@@ -455,12 +454,19 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
 #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,
-                    nr_ue_pbch_vars->dl_ch_estimates,
-                    nr_ue_pbch_vars->rxdataF_ext,
-                    nr_ue_pbch_vars->dl_ch_estimates_ext,
+		    estimateSz,
+                    dl_ch_estimates,
+                    rxdataF_ext,
+                    dl_ch_estimates_ext,
                     symbol,
                     symbol_offset,
                     frame_parms);
@@ -470,115 +476,113 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
 #endif
 
     if (symbol == 1) {
-      max_h = nr_pbch_channel_level(nr_ue_pbch_vars->dl_ch_estimates_ext,
+      max_h = nr_pbch_channel_level(dl_ch_estimates_ext,
                                     frame_parms,
                                     symbol);
-      nr_ue_pbch_vars->log2_maxh = 3+(log2_approx(max_h)/2);
+      log2_maxh = 3+(log2_approx(max_h)/2);
     }
 
 #ifdef DEBUG_PBCH
     LOG_I(PHY,"[PHY] PBCH log2_maxh = %d (%d)\n",nr_ue_pbch_vars->log2_maxh,max_h);
 #endif
-    nr_pbch_channel_compensation(nr_ue_pbch_vars->rxdataF_ext,
-                                 nr_ue_pbch_vars->dl_ch_estimates_ext,
-                                 nr_ue_pbch_vars->rxdataF_comp,
+    nr_pbch_channel_compensation(rxdataF_ext,
+                                 dl_ch_estimates_ext,
+				 nb_re,
+                                 rxdataF_comp,
                                  frame_parms,
                                  symbol,
-                                 nr_ue_pbch_vars->log2_maxh); // log2_maxh+I0_shift
+                                 log2_maxh); // log2_maxh+I0_shift
 
     /*if (frame_parms->nb_antennas_rx > 1)
       pbch_detection_mrc(frame_parms,
-                         nr_ue_pbch_vars->rxdataF_comp,
+                         rxdataF_comp,
                          symbol);*/
 
     /*
         if (mimo_mode == ALAMOUTI) {
-          nr_pbch_alamouti(frame_parms,nr_ue_pbch_vars->rxdataF_comp,symbol);
+          nr_pbch_alamouti(frame_parms,rxdataF_comp,symbol);
         } else if (mimo_mode != SISO) {
           LOG_I(PHY,"[PBCH][RX] Unsupported MIMO mode\n");
           return(-1);
         }
     */
     if (symbol==2) {
-      nr_pbch_quantize(pbch_e_rx,
-                       (short *)&(nr_ue_pbch_vars->rxdataF_comp[0][symbol*240]),
+      nr_pbch_quantize(pbch_e_rx+pbch_e_rx_idx,
+                       (short *)rxdataF_comp[0],
                        144);
-      pbch_e_rx+=144;
+      pbch_e_rx_idx+=144;
     } else {
-      nr_pbch_quantize(pbch_e_rx,
-                       (short *)&(nr_ue_pbch_vars->rxdataF_comp[0][symbol*240]),
+      nr_pbch_quantize(pbch_e_rx+pbch_e_rx_idx,
+                       (short *)rxdataF_comp[0],
                        360);
-      pbch_e_rx+=360;
+      pbch_e_rx_idx+=360;
     }
   }
 
 #ifdef DEBUG_PBCH
-  write_output("rxdataF_comp.m","rxFcomp",&nr_ue_pbch_vars->rxdataF_comp[0][240],240*3,1,1);
+  write_output("rxdataF_comp.m","rxFcomp",rxdataF_comp[0],240*3,1,1);
 #endif
-  pbch_e_rx = nr_ue_pbch_vars->llr;
   //demod_pbch_e = nr_ue_pbch_vars->demod_pbch_e;
 // FT?? cppcheck fix -  pbch_a = nr_ue_pbch_vars->pbch_a;
 #ifdef DEBUG_PBCH
-  //pbch_e_rx = &nr_ue_pbch_vars->llr[0];
-  short *p = (short *)&(nr_ue_pbch_vars->rxdataF_comp[0][20*12]);
+  short *p = (short *)rxdataF_comp[0]);
 
-  for (int cnt = 0; cnt < 864  ; cnt++)
+for (int cnt = 0; cnt < 864  ; cnt++)
     printf("pbch rx llr %d\n",*(pbch_e_rx+cnt));
 
 #endif
   //un-scrambling
-  M =  NR_POLAR_PBCH_E;
-  nushift = (Lmax==4)? i_ssb&3 : i_ssb&7;
+M =  NR_POLAR_PBCH_E;
+nushift = (Lmax==4)? i_ssb&3 : i_ssb&7;
   uint32_t unscrambling_mask = (Lmax==64)?0x100006D:0x1000041;
-
-  nr_pbch_unscrambling(nr_ue_pbch_vars,frame_parms->Nid_cell,nushift,M,NR_POLAR_PBCH_E,0,0);
+  uint32_t pbch_a_interleaved=0;
+uint32_t pbch_a_prime=0;
+nr_pbch_unscrambling(nr_ue_pbch_vars,pbch_e_rx,frame_parms->Nid_cell,nushift,M,NR_POLAR_PBCH_E,0,0,  pbch_a_prime, &pbch_a_interleaved);
   //polar decoding de-rate matching
   const t_nrPolar_params *currentPtr = nr_polar_params( NR_POLAR_PBCH_MESSAGE_TYPE, NR_POLAR_PBCH_PAYLOAD_BITS, NR_POLAR_PBCH_AGGREGATION_LEVEL,1,&ue->polarList);
-  decoderState = polar_decoder_int16(pbch_e_rx,(uint64_t *)&nr_ue_pbch_vars->pbch_a_prime,0,currentPtr);
+  decoderState = polar_decoder_int16(pbch_e_rx,(uint64_t *)&pbch_a_prime,0,currentPtr);
 
   if(decoderState) return(decoderState);
 
-  //  printf("polar decoder output 0x%08x\n",nr_ue_pbch_vars->pbch_a_prime);
+  //  printf("polar decoder output 0x%08x\n",pbch_a_prime);
   // Decoder reversal
   uint32_t a_reversed=0;
 
   for (int i=0; i<NR_POLAR_PBCH_PAYLOAD_BITS; i++)
-    a_reversed |= (((uint64_t)nr_ue_pbch_vars->pbch_a_prime>>i)&1)<<(31-i);
+    a_reversed |= (((uint64_t)pbch_a_prime>>i)&1)<<(31-i);
 
-  nr_ue_pbch_vars->pbch_a_prime = a_reversed;
+  pbch_a_prime = a_reversed;
   //payload un-scrambling
-  nr_ue_pbch_vars->pbch_a_interleaved=0;
   M = (Lmax == 64)? (NR_POLAR_PBCH_PAYLOAD_BITS - 6) : (NR_POLAR_PBCH_PAYLOAD_BITS - 3);
-  nushift = ((nr_ue_pbch_vars->pbch_a_prime>>24)&1) ^ (((nr_ue_pbch_vars->pbch_a_prime>>6)&1)<<1);
-  nr_pbch_unscrambling(nr_ue_pbch_vars,frame_parms->Nid_cell,nushift,M,NR_POLAR_PBCH_PAYLOAD_BITS,1,unscrambling_mask);
-  //printf("nushift %d sfn 3rd %d 2nd %d", nushift,((nr_ue_pbch_vars->pbch_a_prime>>6)&1), ((nr_ue_pbch_vars->pbch_a_prime>>24)&1) );
+  nushift = ((pbch_a_prime>>24)&1) ^ (((pbch_a_prime>>6)&1)<<1);
+nr_pbch_unscrambling(nr_ue_pbch_vars,pbch_e_rx,frame_parms->Nid_cell,nushift,M,NR_POLAR_PBCH_PAYLOAD_BITS,1,unscrambling_mask,pbch_a_prime, &pbch_a_interleaved);
+  //printf("nushift %d sfn 3rd %d 2nd %d", nushift,((pbch_a_prime>>6)&1), ((pbch_a_prime>>24)&1) );
   //payload deinterleaving
   //uint32_t in=0;
   uint32_t out=0;
 
   for (int i=0; i<32; i++) {
-    out |= ((nr_ue_pbch_vars->pbch_a_interleaved>>i)&1)<<(pbch_deinterleaving_pattern[i]);
+    out |= ((pbch_a_interleaved>>i)&1)<<(pbch_deinterleaving_pattern[i]);
 #ifdef DEBUG_PBCH
-    printf("i %d in 0x%08x out 0x%08x ilv %d (in>>i)&1) 0x%08x\n", i, nr_ue_pbch_vars->pbch_a_interleaved, out, pbch_deinterleaving_pattern[i], (nr_ue_pbch_vars->pbch_a_interleaved>>i)&1);
+    printf("i %d in 0x%08x out 0x%08x ilv %d (in>>i)&1) 0x%08x\n", i, pbch_a_interleaved, out, pbch_deinterleaving_pattern[i], (pbch_a_interleaved>>i)&1);
 #endif
   }
 
   uint32_t payload = 0;
-  //uint8_t xtra_byte = 0;
-  nr_ue_pbch_vars->xtra_byte = (out>>24)&0xff;
+  result->xtra_byte = (out>>24)&0xff;
 
   for (int i=0; i<NR_POLAR_PBCH_PAYLOAD_BITS; i++)
     payload |= ((out>>i)&1)<<(NR_POLAR_PBCH_PAYLOAD_BITS-i-1);
 
   for (int i=0; i<3; i++)
-    decoded_output[i] = (uint8_t)((payload>>((3-i)<<3))&0xff);
+    result->decoded_output[i] = (uint8_t)((payload>>((3-i)<<3))&0xff);
 
-  frame_parms->half_frame_bit = ((nr_ue_pbch_vars->xtra_byte>>4)&0x01); // computing the half frame index from the extra byte
+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 += (((nr_ue_pbch_vars->xtra_byte>>(7-i))&0x01)<<(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);
@@ -587,25 +591,26 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
 
   uint8_t frame_number_4lsb = 0;
   for (int i=0; i<4; i++)
-    frame_number_4lsb |= ((nr_ue_pbch_vars->xtra_byte>>i)&1)<<(3-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", nr_ue_pbch_vars->xtra_byte, payload);
+  printf("xtra_byte %x payload %x\n", xtra_byte, payload);
 
   for (int i=0; i<(NR_POLAR_PBCH_PAYLOAD_BITS>>3); i++) {
     //     printf("unscrambling pbch_a[%d] = %x \n", i,pbch_a[i]);
-    printf("[PBCH] decoder payload[%d] = %x\n",i,decoded_output[i]);
+    printf("[PBCH] decoder payload[%d] = %x\n",i,result->decoded_output[i]);
   }
 #endif
 
   nr_downlink_indication_t dl_indication;
-  fapi_nr_rx_indication_t *rx_ind = calloc(1, sizeof(*rx_ind));
-  uint16_t number_pdus = 1;
+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_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);
+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)
     ue->if_inst->dl_indication(&dl_indication, NULL);

openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h

@@ -1153,11 +1153,14 @@ int rx_sss(PHY_VARS_NR_UE *phy_vars_ue,int32_t *tot_metric,uint8_t *flip_max,uin
 */
 int nr_rx_pbch( PHY_VARS_NR_UE *ue,
                 UE_nr_rxtx_proc_t *proc,
+		const int estimateSz,
+		struct complex16 dl_ch_estimates[][estimateSz],
                 NR_UE_PBCH *nr_ue_pbch_vars,
                 NR_DL_FRAME_PARMS *frame_parms,
                 uint8_t eNB_id,
                 uint8_t i_ssb,
-                MIMO_mode_t mimo_mode);
+                MIMO_mode_t mimo_mode,
+		fapiPbch_t* result);
 
 int nr_pbch_detection(UE_nr_rxtx_proc_t *proc,
 		      PHY_VARS_NR_UE *ue,

openair1/PHY/TOOLS/nr_phy_scope.c

@@ -40,6 +40,9 @@ const FL_COLOR water_colors[4] = {FL_BLUE,FL_GREEN,FL_YELLOW,FL_RED};
 typedef struct complex16 scopeSample_t;
 #define SquaredNorm(VaR) ((VaR).r*(VaR).r+(VaR).i*(VaR).i)
 
+typedef struct {
+} scopeGraphData_t;
+
 typedef struct OAIgraph {
   FL_OBJECT *graph;
   FL_OBJECT *text;
@@ -56,7 +59,7 @@ typedef struct OAIgraph {
   boolean_t initDone;
   int iteration;
   void (*gNBfunct) (struct OAIgraph *graph, scopeData_t *p, int UE_id);
-  void (*nrUEfunct)(struct OAIgraph *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id);
+  void (*nrUEfunct)(scopeGraphData_t** data, struct OAIgraph *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id);
 } OAIgraph_t;
 
 /* Forms and Objects */
@@ -140,7 +143,7 @@ static OAIgraph_t gNBcommonGraph( void (*funct) (OAIgraph_t *graph, scopeData_t
   return graph;
 }
 
-static OAIgraph_t nrUEcommonGraph( void (*funct) (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id),
+static OAIgraph_t nrUEcommonGraph( void (*funct) (scopeGraphData_t **data, OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id),
                                    int type, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, const char *label, FL_COLOR pointColor) {
   OAIgraph_t graph;
   commonGraph(&graph, type, x, y, w, h, label, pointColor);
@@ -341,7 +344,7 @@ static void timeResponse (OAIgraph_t *graph, scopeData_t *p, int nb_UEs) {
 static void gNBfreqWaterFall (OAIgraph_t *graph, scopeData_t *p, int nb_UEs) {
   NR_DL_FRAME_PARMS *frame_parms=&p->gNB->frame_parms;
   //use 1st antenna
-  genericWaterFall(graph, (scopeSample_t *)p->rxdataF, frame_parms->samples_per_frame_wCP,
+  genericWaterFall(graph, (scopeSample_t *)p->liveData, frame_parms->samples_per_frame_wCP,
                    frame_parms->slots_per_frame,
                    "X axis: Frequency domain, one subframe");
 }
@@ -515,6 +518,7 @@ void phy_scope_gNB(OAI_phy_scope_t *form,
 
   //fl_check_forms();
 }
+
 static void *scope_thread_gNB(void *arg) {
   scopeData_t *p=(scopeData_t *) arg;
   size_t stksize=0;
@@ -539,11 +543,12 @@ static void *scope_thread_gNB(void *arg) {
 
   return NULL;
 }
+
 static void copyRxdataF(int32_t *data, int slot,  void *scopeData) {
   scopeData_t *scope=(scopeData_t *)scopeData;
-  memcpy(scope->rxdataF + slot*scope->gNB->frame_parms.samples_per_slot_wCP,
+  memcpy(((int32_t*)scope->liveData) + slot*scope->gNB->frame_parms.samples_per_slot_wCP,
          data,
-         scope->gNB->frame_parms.samples_per_slot_wCP);
+         scope->gNB->frame_parms.samples_per_slot_wCP*sizeof(int32_t));
 }
 
 void gNBinitScope(scopeParms_t *p) {
@@ -554,11 +559,11 @@ void gNBinitScope(scopeParms_t *p) {
   scope->ru=p->ru;
   scope->gNB=p->gNB;
   scope->slotFunc=copyRxdataF;
-  AssertFatal(scope->rxdataF=(int32_t *) calloc(p->gNB->frame_parms.samples_per_frame_wCP*sizeof(int32_t),1),"");
+  AssertFatal(scope->liveData= calloc(p->gNB->frame_parms.samples_per_frame_wCP*sizeof(int32_t),1),"");
   pthread_t forms_thread;
   threadCreate(&forms_thread, scope_thread_gNB, p->gNB->scopeData, "scope", -1, OAI_PRIORITY_RT_LOW);
 }
-static void ueWaterFall  (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
+static void ueWaterFall  (scopeGraphData_t **data, OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
   // Received signal in time domain of receive antenna 0
   genericWaterFall(graph,
                    (scopeSample_t *) phy_vars_ue->common_vars.rxdata[0],
@@ -574,13 +579,18 @@ static void ueTimeResponse  (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int
                            phy_vars_ue->frame_parms.samples_per_frame);
 }
 */
-static void ueChannelResponse  (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
+
+static void ueChannelResponse  (scopeGraphData_t **data, OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
   // Channel Impulse Response
+  if (!data[pbchDlChEstimateTime])
+    return;
+  
   genericPowerPerAntena(graph, phy_vars_ue->frame_parms.nb_antennas_rx,
-                        (const scopeSample_t **) phy_vars_ue->pbch_vars[eNB_id]->dl_ch_estimates_time,
+                        (const scopeSample_t **) &data[pbchDlChEstimateTime],
                         phy_vars_ue->frame_parms.ofdm_symbol_size>>3);
 }
-static void ueFreqWaterFall (OAIgraph_t *graph,PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id ) {
+
+static void ueFreqWaterFall (scopeGraphData_t **data, OAIgraph_t *graph,PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id ) {
   NR_DL_FRAME_PARMS *frame_parms=&phy_vars_ue->frame_parms;
   //use 1st antenna
   genericWaterFall(graph,
@@ -624,12 +634,12 @@ static void uePbchFrequencyResp  (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue
   oai_xygraph(graph,freq,chest_f_abs,frame_parms->ofdm_symbol_size,0,10);
 }
 */
-static void uePbchLLR  (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
+static void uePbchLLR  (scopeGraphData_t **data, OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
   // PBCH LLRs
-  if ( !phy_vars_ue->pbch_vars[eNB_id]->llr)
+  if ( !data[pbchLlr])
     return;
 
-  int16_t *pbch_llr = (int16_t *) phy_vars_ue->pbch_vars[eNB_id]->llr;
+  int16_t *pbch_llr = (int16_t *)data[pbchLlr];
   float *llr_pbch, *bit_pbch;
   oai_xygraph_getbuff(graph, &bit_pbch, &llr_pbch, 864, 0);
 
@@ -639,12 +649,13 @@ static void uePbchLLR  (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_
 
   oai_xygraph(graph,bit_pbch,llr_pbch,864,0,10);
 }
-static void uePbchIQ  (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
+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 (!phy_vars_ue->pbch_vars[eNB_id]->rxdataF_comp[0])
-    return;
 
-  scopeSample_t *pbch_comp = (scopeSample_t *) phy_vars_ue->pbch_vars[eNB_id]->rxdataF_comp[0];
+  if (!data[pbchRxdataF_comp])
+    return;
+  
+  scopeSample_t *pbch_comp = (scopeSample_t *) data[pbchRxdataF_comp];
   float *I, *Q;
   oai_xygraph_getbuff(graph, &I, &Q, 180*3, 0);
   memset(I,0,180*3*sizeof(*I));
@@ -673,7 +684,7 @@ static void uePbchIQ  (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_i
   AssertFatal(base <= 180*3,"");
   oai_xygraph(graph,I,Q,base,0, 10);
 }
-static void uePcchLLR  (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
+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)
     return;
@@ -698,7 +709,7 @@ static void uePcchLLR  (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_
   AssertFatal(base <= coded_bits_per_codeword*RX_NB_TH_MAX, "");
   oai_xygraph(graph,bit,llr,base,0,10);
 }
-static void uePcchIQ  (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
+static void uePcchIQ  (scopeGraphData_t **data, OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
   // PDCCH I/Q of MF Output
   if (!phy_vars_ue->pdcch_vars[0][eNB_id]->rxdataF_comp[0])
     return;
@@ -722,7 +733,7 @@ static void uePcchIQ  (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_i
   AssertFatal(base <= nb*RX_NB_TH_MAX, "");
   oai_xygraph(graph,I,Q,base,0,10);
 }
-static void uePdschLLR  (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
+static void uePdschLLR  (scopeGraphData_t **data, OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
   // PDSCH LLRs
   if (!phy_vars_ue->pdsch_vars[0][eNB_id]->llr[0])
     return;
@@ -749,7 +760,7 @@ static void uePdschLLR  (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB
   //fl_set_xyplot_xbounds(form->pdsch_llr,0,coded_bits_per_codeword);
   oai_xygraph(graph,bit,llr,base,0,10);
 }
-static void uePdschIQ  (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
+static void uePdschIQ  (scopeGraphData_t **data, OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
   // PDSCH I/Q of MF Output
   if (!phy_vars_ue->pdsch_vars[0][eNB_id]->rxdataF_comp0[0])
     return;
@@ -776,7 +787,7 @@ static void uePdschIQ  (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_
   AssertFatal(base <= sz*RX_NB_TH_MAX, "");
   oai_xygraph(graph,I,Q,sz*RX_NB_TH_MAX,0,10);
 }
-static void uePdschThroughput  (OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
+static void uePdschThroughput  (scopeGraphData_t **data, OAIgraph_t *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id) {
   /*
   float tput_time_ue[NUMBER_OF_UE_MAX][TPUT_WINDOW_LENGTH] = {{0}};
   float tput_ue[NUMBER_OF_UE_MAX][TPUT_WINDOW_LENGTH] = {{0}};
@@ -869,7 +880,9 @@ static OAI_phy_scope_t *create_phy_scope_nrue( int ID ) {
   fl_show_form (fdui->phy_scope, FL_PLACE_HOTSPOT, FL_FULLBORDER, buf);
   return fdui;
 }
-void phy_scope_nrUE(OAI_phy_scope_t *form,
+
+void phy_scope_nrUE(scopeGraphData_t **UEliveData,
+		    OAI_phy_scope_t *form,
                     PHY_VARS_NR_UE *phy_vars_ue,
                     int eNB_id,
                     int UE_id) {
@@ -886,12 +899,13 @@ void phy_scope_nrUE(OAI_phy_scope_t *form,
   int i=0;
 
   while (form->graph[i].graph) {
-    form->graph[i].nrUEfunct(form->graph+i, phy_vars_ue, eNB_id, UE_id);
+    form->graph[i].nrUEfunct(UEliveData, form->graph+i, phy_vars_ue, eNB_id, UE_id);
     i++;
   }
 
   //fl_check_forms();
 }
+
 static void *nrUEscopeThread(void *arg) {
   PHY_VARS_NR_UE *ue=(PHY_VARS_NR_UE *)arg;
   size_t stksize;
@@ -903,9 +917,12 @@ static void *nrUEscopeThread(void *arg) {
   fl_initialize (&fl_argc, &name, NULL, 0, 0);
   OAI_phy_scope_t  *form_nrue=create_phy_scope_nrue(0);
 
+  scopeGraphData_t *UEliveData[UEdataTypeNumberOfItems];
+  
   while (!oai_exit) {
     fl_freeze_form(form_nrue->phy_scope);
-    phy_scope_nrUE(form_nrue,
+    phy_scope_nrUE(UEliveData,
+		   form_nrue,
                    ue,
                    0,0);
     fl_unfreeze_form(form_nrue->phy_scope);
@@ -915,10 +932,19 @@ static void *nrUEscopeThread(void *arg) {
 
   pthread_exit((void *)arg);
 }
+
+void UEcopyData(enum UEdataType type, void * data, int elementSz, int colSz, int lineSz) {
+ 
+}
+
 void nrUEinitScope(PHY_VARS_NR_UE *ue) {
+  AssertFatal(ue->scopeData=malloc(sizeof(scopeData_t)),"");
+  scopeData_t *scope=(scopeData_t *) ue->scopeData;
+  scope->copyData=UEcopyData;
   pthread_t forms_thread;
-  threadCreate(&forms_thread, nrUEscopeThread, ue, "scope", -1, OAI_PRIORITY_RT_LOW);
+  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");
 

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>
+
 typedef struct {
   int *argc;
   char **argv;
@@ -39,16 +40,25 @@ typedef struct {
   PHY_VARS_gNB *gNB;
 } scopeParms_t;
 
+enum UEdataType {
+  pbchDlChEstimateTime,
+  pbchLlr,
+  pbchRxdataF_comp,
+  UEdataTypeNumberOfItems
+};
 
 typedef struct scopeData_s {
   int *argc;
   char **argv;
   RU_t *ru;
   PHY_VARS_gNB *gNB;
-  int32_t * rxdataF;
+  void * liveData;
   void (*slotFunc)(int32_t* data, int slot,  void * scopeData);
+  void (*copyData)(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__);
 #endif

openair1/PHY/defs_UE.h

@@ -839,6 +839,7 @@ typedef struct {
   /// RF and Interface devices per CC
 
   openair0_device rfdevice;
+  void *scopeData;
 } PHY_VARS_UE;
 
 /* this structure is used to pass both UE phy vars and

openair1/PHY/defs_nr_UE.h

@@ -655,40 +655,6 @@ typedef struct {
 #define PBCH_A 24
 
 typedef struct {
-  /// \brief Pointers to extracted PBCH symbols in frequency-domain.
-  /// - first index: rx antenna [0..nb_antennas_rx[
-  /// - second index: ? [0..287] (hard coded)
-  int32_t **rxdataF_ext;
-  /// \brief Pointers to extracted and compensated PBCH symbols in frequency-domain.
-  /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
-  /// - second index: ? [0..287] (hard coded)
-  int32_t **rxdataF_comp;
-  /// \brief Hold the channel estimates in frequency domain.
-  /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
-  /// - second index: samples? [0..symbols_per_tti*(ofdm_symbol_size+LTE_CE_FILTER_LENGTH)[
-  int32_t **dl_ch_estimates;
-  /// \brief Pointers to downlink channel estimates in frequency-domain extracted in PRBS.
-  /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
-  /// - second index: ? [0..287] (hard coded)
-  int32_t **dl_ch_estimates_ext;
-  /// \brief Hold the channel estimates in time domain (used for tracking).
-  /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
-  /// - second index: samples? [0..2*ofdm_symbol_size[
-  int32_t **dl_ch_estimates_time;
-  int log2_maxh;
-  uint8_t pbch_a[NR_POLAR_PBCH_PAYLOAD_BITS>>3];
-  uint32_t pbch_a_interleaved;
-  uint32_t pbch_a_prime;
-  uint8_t pbch_e[NR_POLAR_PBCH_E];
-  int16_t  demod_pbch_e[NR_POLAR_PBCH_E];
-  /// \brief Pointer to PBCH llrs.
-  /// - first index: ? [0..1919] (hard coded)
-  int16_t *llr;
-  /// \brief Pointer to PBCH decoded output.
-  /// - first index: ? [0..63] (hard coded)
-  uint8_t *decoded_output;
-  /// \brief PBCH additional bits
-  uint8_t xtra_byte;
   /// \brief Total number of PDU errors.
   uint32_t pdu_errors;
   /// \brief Total number of PDU errors 128 frames ago.
@@ -696,7 +662,7 @@ typedef struct {
   /// \brief Total number of consecutive PDU errors.
   uint32_t pdu_errors_conseq;
   /// \brief FER (in percent) .
-  uint32_t pdu_fer;
+  //uint32_t pdu_fer;
 } NR_UE_PBCH;
 
 typedef struct {
@@ -1075,7 +1041,7 @@ typedef struct {
 #endif
   
   int dl_stats[5];
-
+  void* scopeData;
 } PHY_VARS_NR_UE;
 
 /* this structure is used to pass both UE phy vars and

openair1/SCHED_NR_UE/defs.h

@@ -82,6 +82,11 @@
 #define DAQ_AGC_OFF 0
 
 
+typedef struct {
+  uint8_t decoded_output[64];
+  uint8_t xtra_byte;
+} fapiPbch_t;
+
 /** @addtogroup _PHY_PROCEDURES_
  * @{
  */
@@ -398,7 +403,8 @@ void nr_fill_rx_indication(fapi_nr_rx_indication_t *rx_ind,
                            NR_UE_DLSCH_t *dlsch0,
                            NR_UE_DLSCH_t *dlsch1,
                            uint16_t n_pdus,
-                           UE_nr_rxtx_proc_t *proc);
+                           UE_nr_rxtx_proc_t *proc,
+			   void * typeSpecific);
 
 bool nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
                             UE_nr_rxtx_proc_t *proc,

openair1/SCHED_NR_UE/phy_procedures_nr_ue.c

@@ -118,7 +118,8 @@ void nr_fill_rx_indication(fapi_nr_rx_indication_t *rx_ind,
                            NR_UE_DLSCH_t *dlsch0,
                            NR_UE_DLSCH_t *dlsch1,
                            uint16_t n_pdus,
-			   UE_nr_rxtx_proc_t *proc ){
+			   UE_nr_rxtx_proc_t *proc,
+			   void * typeSpecific){
 
 
   NR_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
@@ -162,8 +163,11 @@ void nr_fill_rx_indication(fapi_nr_rx_indication_t *rx_ind,
       rx_ind->rx_indication_body[n_pdus - 1].pdsch_pdu.pdu_length = dlsch0->harq_processes[dlsch0->current_harq_pid]->TBS / 8;
     break;
     case FAPI_NR_RX_PDU_TYPE_SSB:
-      rx_ind->rx_indication_body[n_pdus - 1].ssb_pdu.pdu = ue->pbch_vars[gNB_id]->decoded_output;
-      rx_ind->rx_indication_body[n_pdus - 1].ssb_pdu.additional_bits = ue->pbch_vars[gNB_id]->xtra_byte;
+      rx_ind->rx_indication_body[n_pdus - 1].ssb_pdu.pdu=malloc(sizeof(((fapiPbch_t*)typeSpecific)->decoded_output));
+      memcpy(rx_ind->rx_indication_body[n_pdus - 1].ssb_pdu.pdu,
+	     ((fapiPbch_t*)typeSpecific)->decoded_output,
+	     sizeof(((fapiPbch_t*)typeSpecific)->decoded_output));
+      rx_ind->rx_indication_body[n_pdus - 1].ssb_pdu.additional_bits = ((fapiPbch_t*)typeSpecific)->xtra_byte;
       rx_ind->rx_indication_body[n_pdus - 1].ssb_pdu.ssb_index = (frame_parms->ssb_index)&0x7;
       rx_ind->rx_indication_body[n_pdus - 1].ssb_pdu.ssb_length = frame_parms->Lmax;
       rx_ind->rx_indication_body[n_pdus - 1].ssb_pdu.cell_id = frame_parms->Nid_cell;
@@ -353,10 +357,9 @@ void nr_ue_measurement_procedures(uint16_t l,
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_MEASUREMENT_PROCEDURES, VCD_FUNCTION_OUT);
 }
 
-void nr_ue_pbch_procedures(uint8_t gNB_id,
+static void nr_ue_pbch_procedures(uint8_t gNB_id,
 			   PHY_VARS_NR_UE *ue,
-			   UE_nr_rxtx_proc_t *proc,
-			   uint8_t abstraction_flag)
+				  UE_nr_rxtx_proc_t *proc,int estimateSz, struct complex16 dl_ch_estimates[][estimateSz])
 {
   int ret = 0;
 
@@ -368,13 +371,15 @@ void nr_ue_pbch_procedures(uint8_t gNB_id,
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_PBCH_PROCEDURES, VCD_FUNCTION_IN);
 
   LOG_D(PHY,"[UE  %d] Frame %d Slot %d, Trying PBCH (NidCell %d, gNB_id %d)\n",ue->Mod_id,frame_rx,nr_slot_rx,ue->frame_parms.Nid_cell,gNB_id);
-
+  fapiPbch_t result;
   ret = nr_rx_pbch(ue, proc,
+		   estimateSz, dl_ch_estimates,
                    ue->pbch_vars[gNB_id],
                    &ue->frame_parms,
                    gNB_id,
                    (ue->frame_parms.ssb_index)&7,
-                   SISO);
+                   SISO,
+		   &result);
 
   if (ret==0) {
 
@@ -444,7 +449,6 @@ void nr_ue_pbch_procedures(uint8_t gNB_id,
   }
 
   if (frame_rx % 100 == 0) {
-    ue->pbch_vars[gNB_id]->pdu_fer = ue->pbch_vars[gNB_id]->pdu_errors - ue->pbch_vars[gNB_id]->pdu_errors_last;
     ue->pbch_vars[gNB_id]->pdu_errors_last = ue->pbch_vars[gNB_id]->pdu_errors;
   }
 
@@ -794,16 +798,16 @@ bool nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
     switch (pdsch) {
       case RA_PDSCH:
         nr_fill_dl_indication(&dl_indication, NULL, rx_ind, proc, ue, gNB_id);
-        nr_fill_rx_indication(rx_ind, FAPI_NR_RX_PDU_TYPE_RAR, gNB_id, ue, dlsch0, NULL, number_pdus, proc);
+        nr_fill_rx_indication(rx_ind, FAPI_NR_RX_PDU_TYPE_RAR, gNB_id, ue, dlsch0, NULL, number_pdus, proc, NULL);
         ue->UE_mode[gNB_id] = RA_RESPONSE;
         break;
       case PDSCH:
         nr_fill_dl_indication(&dl_indication, NULL, rx_ind, proc, ue, gNB_id);
-        nr_fill_rx_indication(rx_ind, FAPI_NR_RX_PDU_TYPE_DLSCH, gNB_id, ue, dlsch0, NULL, number_pdus, proc);
+        nr_fill_rx_indication(rx_ind, FAPI_NR_RX_PDU_TYPE_DLSCH, gNB_id, ue, dlsch0, NULL, number_pdus, proc, NULL);
         break;
       case SI_PDSCH:
         nr_fill_dl_indication(&dl_indication, NULL, rx_ind, proc, ue, gNB_id);
-        nr_fill_rx_indication(rx_ind, FAPI_NR_RX_PDU_TYPE_SIB, gNB_id, ue, dlsch0, NULL, number_pdus, proc);
+        nr_fill_rx_indication(rx_ind, FAPI_NR_RX_PDU_TYPE_SIB, gNB_id, ue, dlsch0, NULL, number_pdus, proc, NULL);
         break;
       default:
         break;
@@ -1399,6 +1403,9 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,
   if (slot_ssb) {
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SLOT_FEP_PBCH, VCD_FUNCTION_IN);
     LOG_D(PHY," ------  PBCH ChannelComp/LLR: frame.slot %d.%d ------  \n", frame_rx%1024, nr_slot_rx);
+    const int estimateSz=7*2*sizeof(int)*fp->ofdm_symbol_size;
+    struct complex16 dl_ch_estimates[fp->nb_antennas_rx][estimateSz];
+    struct complex16 dl_ch_estimates_time[fp->nb_antennas_rx][estimateSz];
     for (int i=1; i<4; i++) {
 
       nr_slot_fep(ue,
@@ -1408,7 +1415,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,
 
 
       start_meas(&ue->dlsch_channel_estimation_stats);
-      nr_pbch_channel_estimation(ue,proc,gNB_id,nr_slot_rx,(ue->symbol_offset+i)%(fp->symbols_per_slot),i-1,(fp->ssb_index)&7,fp->half_frame_bit);
+      nr_pbch_channel_estimation(ue, estimateSz, dl_ch_estimates, dl_ch_estimates_time,proc,gNB_id,nr_slot_rx,(ue->symbol_offset+i)%(fp->symbols_per_slot),i-1,(fp->ssb_index)&7,fp->half_frame_bit);
       stop_meas(&ue->dlsch_channel_estimation_stats);
     }
 
@@ -1417,13 +1424,14 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,
     if ((ue->decode_MIB == 1) && slot_pbch) {
 
       LOG_D(PHY," ------  Decode MIB: frame.slot %d.%d ------  \n", frame_rx%1024, nr_slot_rx);
-      nr_ue_pbch_procedures(gNB_id, ue, proc, 0);
+      nr_ue_pbch_procedures(gNB_id, ue, proc, estimateSz, dl_ch_estimates);
 
       if (ue->no_timing_correction==0) {
         LOG_D(PHY,"start adjust sync slot = %d no timing %d\n", nr_slot_rx, ue->no_timing_correction);
         nr_adjust_synch_ue(fp,
                            ue,
                            gNB_id,
+			   estimateSz, dl_ch_estimates_time,
                            frame_rx,
                            nr_slot_rx,
                            0,

openair1/SIMULATION/NR_PHY/nr_dummy_functions.c

 #include "nfapi/oai_integration/vendor_ext.h"
 
+
 int oai_nfapi_hi_dci0_req(nfapi_hi_dci0_request_t *hi_dci0_req)             { return(0);  }
 int oai_nfapi_tx_req(nfapi_tx_request_t *tx_req)                            { return(0);  }
 int oai_nfapi_dl_config_req(nfapi_dl_config_request_t *dl_config_req)       { return(0);  }
@@ -35,4 +36,5 @@ void nr_fill_rx_indication(fapi_nr_rx_indication_t *rx_ind,
                            NR_UE_DLSCH_t *dlsch0,
                            NR_UE_DLSCH_t *dlsch1,
                            uint16_t n_pdus,
-                           UE_nr_rxtx_proc_t *proc) {}
+                           UE_nr_rxtx_proc_t *proc,
+			   void * typeSpecific ) {}

openair1/SIMULATION/NR_PHY/pbchsim.c

@@ -720,6 +720,9 @@ int main(int argc, char **argv)
 	UE_nr_rxtx_proc_t proc={0};
 	UE->rx_offset=0;
 	uint8_t ssb_index = 0;
+	const int estimateSz=7*2*sizeof(int)*frame_parms->ofdm_symbol_size;
+	struct complex16 dl_ch_estimates[frame_parms->nb_antennas_rx][estimateSz];
+	struct complex16 dl_ch_estimates_time[frame_parms->nb_antennas_rx][estimateSz];
         while (!((SSB_positions >> ssb_index) & 0x01)) ssb_index++;  // to select the first transmitted ssb
 	UE->symbol_offset = nr_get_ssb_start_symbol(frame_parms,ssb_index);
 
@@ -730,17 +733,20 @@ int main(int argc, char **argv)
                       i%frame_parms->symbols_per_slot,
                       ssb_slot);
 
-          nr_pbch_channel_estimation(UE,&proc,0,ssb_slot,i%frame_parms->symbols_per_slot,i-(UE->symbol_offset+1),ssb_index%8,n_hf);
+          nr_pbch_channel_estimation(UE,estimateSz, dl_ch_estimates, dl_ch_estimates_time, &proc, 
+				     0,ssb_slot,i%frame_parms->symbols_per_slot,i-(UE->symbol_offset+1),ssb_index%8,n_hf);
 
         }
-
+	fapiPbch_t result;
         ret = nr_rx_pbch(UE,
                          &proc,
-                         UE->pbch_vars[0],
+			 estimateSz, dl_ch_estimates,
+			 UE->pbch_vars[0],
                          frame_parms,
                          0,
                          ssb_index%8,
-                         SISO);
+                         SISO,
+			 &result);
 
 	if (ret==0) {
 	  //UE->rx_ind.rx_indication_body->mib_pdu.ssb_index;  //not yet detected automatically
@@ -749,9 +755,9 @@ int main(int argc, char **argv)
 	  for (int i=0; i<8; i++)
 	    gNB_xtra_byte |= ((gNB->pbch.pbch_a>>(31-i))&1)<<(7-i);
  
-	  payload_ret = (UE->pbch_vars[0]->xtra_byte == gNB_xtra_byte);
+	  payload_ret = (result.xtra_byte == gNB_xtra_byte);
 	  for (i=0;i<3;i++){
-	    payload_ret += (UE->pbch_vars[0]->decoded_output[i] == ((msgDataTx.ssb[ssb_index].ssb_pdu.ssb_pdu_rel15.bchPayload>>(8*i)) & 0xff));
+	    payload_ret += (result.decoded_output[i] == ((msgDataTx.ssb[ssb_index].ssb_pdu.ssb_pdu_rel15.bchPayload>>(8*i)) & 0xff));
 	  } 
 	  //printf("xtra byte gNB: 0x%02x UE: 0x%02x\n",gNB_xtra_byte, UE->pbch_vars[0]->xtra_byte);
 	  //printf("ret %d\n", payload_ret);