Merge branch 'nr_pbchsim' of https://gitlab.eurecom.fr/oai/openairinterface5g into nr_pbchsim

cmake_targets/CMakeLists.txt

@@ -1296,7 +1296,7 @@ set(PHY_SRC_UE
   ${OPENAIR1_DIR}/PHY/NR_REFSIG/nr_gold.c
   ${OPENAIR1_DIR}/PHY/TOOLS/file_output.c
   ${OPENAIR1_DIR}/PHY/TOOLS/cadd_vv.c
-  ${OPENAIR1_DIR}/PHY/TOOLS/lte_dfts.c
+  #${OPENAIR1_DIR}/PHY/TOOLS/lte_dfts.c
   ${OPENAIR1_DIR}/PHY/TOOLS/log2_approx.c
   ${OPENAIR1_DIR}/PHY/TOOLS/cmult_sv.c
   ${OPENAIR1_DIR}/PHY/TOOLS/cmult_vv.c
@@ -1334,7 +1334,7 @@ set(PHY_SRC_UE
   ${OPENAIR1_DIR}/PHY/NR_UE_ESTIMATION/nr_dl_channel_estimation.c
   ${OPENAIR1_DIR}/PHY/TOOLS/file_output.c
   ${OPENAIR1_DIR}/PHY/TOOLS/cadd_vv.c
-  ${OPENAIR1_DIR}/PHY/TOOLS/lte_dfts.c
+ # ${OPENAIR1_DIR}/PHY/TOOLS/lte_dfts.c
   ${OPENAIR1_DIR}/PHY/TOOLS/log2_approx.c
   ${OPENAIR1_DIR}/PHY/TOOLS/cmult_sv.c
   ${OPENAIR1_DIR}/PHY/TOOLS/cmult_vv.c

openair1/PHY/CODING/nrPolar_tools/nr_polar_decoder.c

@@ -1069,9 +1069,17 @@ int8_t polar_decoder_int16(int16_t *input,
   nr_polar_deinterleaver(polarParams->nr_polar_CPrime, polarParams->nr_polar_B, polarParams->interleaving_pattern, polarParams->K);
 
   //Remove the CRC (â)
-  for (int j = 0; j < polarParams->payloadBits; j++) polarParams->nr_polar_A[j]=polarParams->nr_polar_B[j];  
-
-  nr_byte2bit_uint8_32_t(polarParams->nr_polar_A, polarParams->payloadBits, out);
-  
+  //for (int j = 0; j < polarParams->payloadBits; j++) polarParams->nr_polar_A[j]=polarParams->nr_polar_B[j];  
+
+  // Check the CRC
+  for (int j=0;j<polarParams->crcParityBits;j++) {
+    int crcbit=0;
+    for (int i=0;i<polarParams->payloadBits;i++)
+      crcbit = crcbit ^ (polarParams->crc_generator_matrix[i][j] & polarParams->nr_polar_B[i]);
+    if (crcbit != polarParams->nr_polar_B[polarParams->payloadBits+j]) return(-1); 
+  }
+  // pack into ceil(payloadBits/32) 32 bit words, lowest index in MSB
+  //  nr_byte2bit_uint8_32_t(polarParams->nr_polar_A, polarParams->payloadBits, out);
+  nr_byte2bit_uint8_32_t(polarParams->nr_polar_B, polarParams->payloadBits, out);
   return(0);
 }

openair1/PHY/CODING/nrPolar_tools/nr_polar_decoding_tools.c

@@ -443,7 +443,7 @@ void applyGtoright(t_nrPolar_params *pp,decoder_node_t *node) {
     }
     else 
 #endif
-      {// equvalent scalar code to above, activated only on non x86/ARM architectures
+      {// equvalent scalar code to above, activated only on non x86/ARM architectures or Nv=1,2
 	for (int i=0;i<node->Nv/2;i++) {
 	  alpha_r[i] = alpha_v[i+(node->Nv/2)] - (betal[i]*alpha_v[i]);
 	}

openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h

@@ -361,11 +361,13 @@ static inline void nr_polar_interleaver(uint8_t *input,
 }
 
 static inline void nr_polar_deinterleaver(uint8_t *input,
-										  uint8_t *output,
-										  uint16_t *pattern,
-										  uint16_t size)
+					  uint8_t *output,
+					  uint16_t *pattern,
+					  uint16_t size)
 {
-	for (int i=0; i<size; i++) output[pattern[i]]=input[i];
+  for (int i=0; i<size; i++) {
+    output[pattern[i]]=input[i];
+  }
 }
 
 #endif

openair1/PHY/CODING/nrPolar_tools/nr_polar_encoder.c

@@ -54,7 +54,7 @@ void polar_encoder(uint32_t *in,
 													   polarParams->nr_polar_crc,
 													   polarParams->payloadBits,
 													   polarParams->crcParityBits);
-		for (uint8_t i = 0; i < polarParams->crcParityBits; i++)
+		for (uint8_t i = 0; i < polarParams->crcParityBits; i++) 
 			polarParams->nr_polar_crc[i] = (polarParams->nr_polar_crc[i] % 2);
 
 		//Attach CRC to the Transport Block. (a to b)

openair1/PHY/CODING/nr_polar_init.c

@@ -185,9 +185,9 @@ void nr_polar_print_polarParams(t_nrPolar_paramsPtr polarParams)
 }
 
 t_nrPolar_paramsPtr nr_polar_params (t_nrPolar_paramsPtr polarParams,
-									 int8_t messageType,
-									 uint16_t messageLength,
-									 uint8_t aggregation_level)
+				     int8_t messageType,
+				     uint16_t messageLength,
+				     uint8_t aggregation_level)
 {
 	t_nrPolar_paramsPtr currentPtr = NULL;
 

openair1/PHY/INIT/nr_init.c

@@ -100,6 +100,8 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
   gNB->check_for_MUMIMO_transmissions=0;
  
   while(gNB->configured == 0) usleep(10000);
+
+  init_dfts();
 /*
   LOG_I(PHY,"[gNB %"PRIu8"] Initializing DL_FRAME_PARMS : N_RB_DL %"PRIu8", PHICH Resource %d, PHICH Duration %d nb_antennas_tx:%u nb_antennas_rx:%u PRACH[rootSequenceIndex:%u prach_Config_enabled:%u configIndex:%u highSpeed:%u zeroCorrelationZoneConfig:%u freqOffset:%u]\n",
         gNB->Mod_id,
@@ -367,7 +369,7 @@ void install_schedule_handlers(IF_Module_t *if_inst)
 
 /// this function is a temporary addition for NR configuration
 
-void nr_phy_config_request_sim(PHY_VARS_gNB *gNB)
+void nr_phy_config_request_sim(PHY_VARS_gNB *gNB,int N_RB_DL,int N_RB_UL,int mu)
 {
   NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
   nfapi_nr_config_request_t *gNB_config = &gNB->gNB_config;
@@ -375,14 +377,14 @@ void nr_phy_config_request_sim(PHY_VARS_gNB *gNB)
   //overwrite for new NR parameters
   gNB_config->nfapi_config.rf_bands.rf_band[0] = 22;
   gNB_config->nfapi_config.earfcn.value = 6600;
-  gNB_config->subframe_config.numerology_index_mu.value = 1;
-  gNB_config->subframe_config.duplex_mode.value = FDD;
+  gNB_config->subframe_config.numerology_index_mu.value = mu;
+  gNB_config->subframe_config.duplex_mode.value = TDD;
   gNB_config->rf_config.tx_antenna_ports.value = 1;
-  gNB_config->rf_config.dl_carrier_bandwidth.value = 106;
-  gNB_config->rf_config.ul_carrier_bandwidth.value = 106;
+  gNB_config->rf_config.dl_carrier_bandwidth.value = N_RB_DL;
+  gNB_config->rf_config.ul_carrier_bandwidth.value = N_RB_UL;
   gNB_config->sch_config.half_frame_index.value = 0;
   gNB_config->sch_config.ssb_subcarrier_offset.value = 0;
-  gNB_config->sch_config.n_ssb_crb.value = 86;
+  gNB_config->sch_config.n_ssb_crb.value = (N_RB_DL-20)>>1;
   gNB_config->sch_config.ssb_subcarrier_offset.value = 0;
 
 

openair1/PHY/INIT/nr_init_ue.c

@@ -655,15 +655,16 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
   int i,j,k,l;
   int eNB_id;
   int th_id;
-
+  int n_ssb_crb=(fp->N_RB_DL-20)>>1;
   abstraction_flag = 0;
   fp->nb_antennas_tx = 1;
   fp->nb_antennas_rx=1;
 
+
   printf("Initializing UE vars (abstraction %"PRIu8") for eNB TXant %"PRIu8", UE RXant %"PRIu8"\n",abstraction_flag,fp->nb_antennas_tx,fp->nb_antennas_rx);
   //LOG_D(PHY,"[MSC_NEW][FRAME 00000][PHY_UE][MOD %02u][]\n", ue->Mod_id+NB_eNB_INST);
   
-  nr_init_frame_parms_ue(&ue->frame_parms);
+  nr_init_frame_parms_ue(&ue->frame_parms,NR_MU_1,NORMAL,n_ssb_crb,0);
   phy_init_nr_top(ue);
 
   // many memory allocation sizes are hard coded
@@ -941,43 +942,25 @@ void init_nr_ue_transport(PHY_VARS_NR_UE *ue,int abstraction_flag) {
 
 void phy_init_nr_top(PHY_VARS_NR_UE *ue)
 {
-	NR_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
-	NR_UE_DLSCH_t *dlsch0 = ue->dlsch[0][0][0];
-	dlsch0 =(NR_UE_DLSCH_t *)malloc16(sizeof(NR_UE_DLSCH_t));
-
+  NR_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
+  NR_UE_DLSCH_t *dlsch0 = ue->dlsch[0][0][0];
+  dlsch0 =(NR_UE_DLSCH_t *)malloc16(sizeof(NR_UE_DLSCH_t));
+  
   crcTableInit();
 
   init_dfts();
-  
-  ccodedot11_init();
-  ccodedot11_init_inv();
-
-  ccodelte_init();
-  ccodelte_init_inv();
-
-  //treillis_table_init();
-
-  phy_generate_viterbi_tables();
-  phy_generate_viterbi_tables_lte();
-
-  //init_td8();
-  //init_td16();
-#ifdef __AVX2__
-  //init_td16avx2();
-#endif
 
   init_context_synchro_nr(frame_parms);
 
   generate_ul_reference_signal_sequences(SHRT_MAX);
 
   // Polar encoder init for PBCH
-  //nr_polar_init(&frame_parms->pbch_polar_params, 1);
-  /*t_nrPolar_paramsPtr nrPolar_params = NULL, currentPtr = NULL;
-  nr_polar_init(&ue->nrPolar_params,
-    		  	  	NR_POLAR_PBCH_MESSAGE_TYPE,
-					NR_POLAR_PBCH_PAYLOAD_BITS,
-					NR_POLAR_PBCH_AGGREGATION_LEVEL);*/
 
+  ue->nrPolar_params = NULL;
+  nr_polar_init(&ue->nrPolar_params,
+		NR_POLAR_PBCH_MESSAGE_TYPE,
+		NR_POLAR_PBCH_PAYLOAD_BITS,
+		NR_POLAR_PBCH_AGGREGATION_LEVEL);
   //lte_sync_time_init(frame_parms);
 
   //generate_ul_ref_sigs();

openair1/PHY/INIT/phy_init.h

@@ -377,11 +377,12 @@ void phy_config_request(PHY_Config_t *phy_config);
 int init_frame_parms(LTE_DL_FRAME_PARMS *frame_parms,uint8_t osf);
 void dump_frame_parms(LTE_DL_FRAME_PARMS *frame_parms);
 int nr_init_frame_parms(nfapi_nr_config_request_t* config, NR_DL_FRAME_PARMS *frame_parms);
-int nr_init_frame_parms_ue(NR_DL_FRAME_PARMS *frame_parms);
+int nr_init_frame_parms_ue(NR_DL_FRAME_PARMS *frame_parms,int mu,int Ncp,int n_ssb_crb,int ssb_subcarrier_offset);
 int init_nr_ue_signal(PHY_VARS_NR_UE *ue,int nb_connected_eNB,uint8_t abstraction_flag);
 void nr_dump_frame_parms(NR_DL_FRAME_PARMS *frame_parms);
 int phy_init_nr_gNB(PHY_VARS_gNB *gNB, unsigned char is_secondary_gNB, unsigned char abstraction_flag);
 void nr_phy_config_request(NR_PHY_Config_t *gNB);
+void nr_phy_config_request_sim(PHY_VARS_gNB *gNB,int N_RB_DL,int N_RB_UL,int mu);
 void phy_free_nr_gNB(PHY_VARS_gNB *gNB);
 int l1_north_init_gNB(void);
 

openair1/PHY/LTE_UE_TRANSPORT/initial_sync.c

@@ -285,6 +285,7 @@ int initial_sync(PHY_VARS_UE *ue, runmode_t mode)
   init_frame_parms(frame_parms,1);
   /*
   LOG_M("rxdata0.m","rxd0",ue->common_vars.rxdata[0],10*frame_parms->samples_per_tti,1,1);
+
   exit(-1);
   */
   sync_pos = lte_sync_time(ue->common_vars.rxdata,

openair1/PHY/MODULATION/ofdm_mod.c

@@ -122,10 +122,10 @@ void PHY_ofdm_mod(int *input,                       /// pointer to complex input
 
   case 3072:
     idft = idft3072;
-
+    break;
   case 4096:
     idft = idft4096;
-
+    break;
   default:
     idft = idft512;
     break;

openair1/PHY/MODULATION/slot_fep_nr.c

@@ -30,12 +30,12 @@
 #define SOFFSET 0
 
 int nr_slot_fep(PHY_VARS_NR_UE *ue,
-             unsigned char l,
-             unsigned char Ns,
-             int sample_offset,
-             int no_prefix,
-			 int reset_freq_est,
-			 NR_CHANNEL_EST_t channel)
+		unsigned char l,
+		unsigned char Ns,
+		int sample_offset,
+		int no_prefix,
+		int reset_freq_est,
+		NR_CHANNEL_EST_t channel)
 {
   NR_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
   NR_UE_COMMON *common_vars   = &ue->common_vars;
@@ -61,7 +61,7 @@ int nr_slot_fep(PHY_VARS_NR_UE *ue,
   int uespec_pilot[9][1200];*/
 
   void (*dft)(int16_t *,int16_t *, int);
-  int tmp_dft_in[2048] __attribute__ ((aligned (32)));  // This is for misalignment issues for 6 and 15 PRBs
+  int tmp_dft_in[8192] __attribute__ ((aligned (32)));  // This is for misalignment issues for 6 and 15 PRBs
 
   switch (frame_parms->ofdm_symbol_size) {
   case 128:
@@ -88,6 +88,14 @@ int nr_slot_fep(PHY_VARS_NR_UE *ue,
     dft = dft2048;
     break;
 
+  case 4096:
+    dft = dft4096;
+    break;
+
+  case 8192:
+    dft = dft8192;
+    break;
+
   default:
     dft = dft512;
     break;
@@ -143,7 +151,6 @@ int nr_slot_fep(PHY_VARS_NR_UE *ue,
 #if UE_TIMING_TRACE
         stop_meas(&ue->rx_dft_stats);
 #endif
-
       }
     } else {
       rx_offset += (frame_parms->ofdm_symbol_size+nb_prefix_samples)*l;// +
@@ -191,20 +198,17 @@ int nr_slot_fep(PHY_VARS_NR_UE *ue,
 
   switch(channel){
   case NR_PBCH_EST:
-    //if ((l>4) && (l<8)) {
-      for (aa=0; aa<frame_parms->nb_antenna_ports_eNB; aa++) {
 
-//#ifdef DEBUG_FEP
-        printf("Channel estimation eNB %d, aatx %d, slot %d, symbol %d\n",eNB_id,aa,Ns,l);
-//#endif
+#ifdef DEBUG_FEP
+    printf("Channel estimation eNB %d, slot %d, symbol %d\n",eNB_id,Ns,l);
+#endif
 #if UE_TIMING_TRACE
-        start_meas(&ue->dlsch_channel_estimation_stats);
+    start_meas(&ue->dlsch_channel_estimation_stats);
 #endif
-        nr_pbch_channel_estimation(ue,eNB_id,0,
-                                  Ns,
-                                  aa,
-                                  l,
-                                  symbol);
+    nr_pbch_channel_estimation(ue,eNB_id,0,
+			       Ns,
+			       l,
+			       symbol);
       //}
 #if UE_TIMING_TRACE
         stop_meas(&ue->dlsch_channel_estimation_stats);
@@ -232,53 +236,48 @@ int nr_slot_fep(PHY_VARS_NR_UE *ue,
 #endif
 
       }
-    }
+
   break;
 
   case NR_PDCCH_EST:
-      for (aa=0; aa<frame_parms->nb_antenna_ports_eNB; aa++) {
 
 #ifdef DEBUG_FEP
-          printf("PDCCH Channel estimation eNB %d, aatx %d, slot %d, symbol %d start_sc %d\n",eNB_id,aa,Ns,l,coreset_start_subcarrier);
+    printf("PDCCH Channel estimation eNB %d, aatx %d, slot %d, symbol %d start_sc %d\n",eNB_id,aa,Ns,l,coreset_start_subcarrier);
 #endif
 #if UE_TIMING_TRACE
-          start_meas(&ue->dlsch_channel_estimation_stats);
+    start_meas(&ue->dlsch_channel_estimation_stats);
 #endif
-          nr_pdcch_channel_estimation(ue,eNB_id,0,
-                                    Ns,
-                                    aa,
-                                    l,
-                                    symbol,
-									coreset_start_subcarrier,
-									nb_rb_coreset);
+    nr_pdcch_channel_estimation(ue,eNB_id,0,
+				Ns,
+				l,
+				symbol,
+				coreset_start_subcarrier,
+				nb_rb_coreset);
 #if UE_TIMING_TRACE
-        stop_meas(&ue->dlsch_channel_estimation_stats);
+    stop_meas(&ue->dlsch_channel_estimation_stats);
 #endif
-      }
+    
     break;
-
+    
   case NR_PDSCH_EST:
-      for (aa=0; aa<frame_parms->nb_antenna_ports_eNB; aa++) {
-
 #ifdef DEBUG_FEP
-          printf("Channel estimation eNB %d, aatx %d, slot %d, symbol %d\n",eNB_id,aa,Ns,l);
+    printf("Channel estimation eNB %d, aatx %d, slot %d, symbol %d\n",eNB_id,aa,Ns,l);
 #endif
 #if UE_TIMING_TRACE
-          start_meas(&ue->dlsch_channel_estimation_stats);
+    start_meas(&ue->dlsch_channel_estimation_stats);
 #endif
-          nr_pdsch_channel_estimation(ue,eNB_id,0,
-                                    Ns,
-                                    aa,
-                                    l,
-                                    symbol,
-									bwp_start_subcarrier,
-									nb_rb_pdsch);
+    nr_pdsch_channel_estimation(ue,eNB_id,0,
+				Ns,
+				l,
+				symbol,
+				bwp_start_subcarrier,
+				nb_rb_pdsch);
 #if UE_TIMING_TRACE
-        stop_meas(&ue->dlsch_channel_estimation_stats);
+    stop_meas(&ue->dlsch_channel_estimation_stats);
 #endif
-      }
+    
     break;
-
+    
   case NR_SSS_EST:
   break;
 

openair1/PHY/NR_REFSIG/nr_dmrs_rx.c

@@ -106,13 +106,13 @@ short nr_rx_mod_table[NR_MOD_TABLE_SIZE_SHORT] = {0,0,23170,-23170,-23170,23170,
 }*/
 
 int nr_pdsch_dmrs_rx(PHY_VARS_NR_UE *ue,
-						uint8_t eNB_offset,
-						unsigned int Ns,
-						unsigned int nr_gold_pdsch[2][20][2][21],
-						int32_t *output,
-						unsigned short p,
-						int length_dmrs,
-						unsigned short nb_rb_pdsch)
+		     uint8_t eNB_offset,
+		     unsigned int Ns,
+		     unsigned int nr_gold_pdsch[2][20][2][21],
+		     int32_t *output,
+		     unsigned short p,
+		     int length_dmrs,
+		     unsigned short nb_rb_pdsch)
 {
   int32_t qpsk[4],nqpsk[4],*qpsk_p, n;
   //int w,mprime,ind,l,ind_dword,ind_qpsk_symb,kp,lp, config_type, k;
@@ -216,26 +216,38 @@ int nr_pdcch_dmrs_rx(PHY_VARS_NR_UE *ue,
 	return(0);
 }
 
-int nr_pbch_dmrs_rx(unsigned int *nr_gold_pbch,
-					int32_t *output	)
+int nr_pbch_dmrs_rx(int symbol,unsigned int *nr_gold_pbch,int32_t *output	)
 {
-    int m;
-    uint8_t idx=0;
-
-    /// QPSK modulation
-    for (m=0; m<NR_PBCH_DMRS_LENGTH>>1; m++) {
-      idx = ((((nr_gold_pbch[(m<<1)>>5])>>((m<<1)&0x1f))&1)<<1) ^ (((nr_gold_pbch[((m<<1)+1)>>5])>>(((m<<1)+1)&0x1f))&1);
-      ((int16_t*)output)[m<<1] = nr_rx_mod_table[(NR_MOD_TABLE_QPSK_OFFSET + idx)<<1];
-      ((int16_t*)output)[(m<<1)+1] = nr_rx_mod_table[((NR_MOD_TABLE_QPSK_OFFSET + idx)<<1) + 1];
-
+  int m,m0,m1;
+  uint8_t idx=0;
+  AssertFatal(symbol>=0 && symbol <3,"illegal symbol %d\n",symbol);
+  if (symbol == 0) {
+    m0=0;
+    m1=60;
+  }
+  else if (symbol == 1) {
+    m0=60;
+    m1=84;
+  }
+  else {
+    m0=84;
+    m1=144;
+  }
+  //    printf("Generating pilots symbol %d, m0 %d, m1 %d\n",symbol,m0,m1);
+  /// QPSK modulation
+  for (m=m0; m<m1; m++) {
+    idx = ((((nr_gold_pbch[(m<<1)>>5])>>((m<<1)&0x1f))&1)<<1) ^ (((nr_gold_pbch[((m<<1)+1)>>5])>>(((m<<1)+1)&0x1f))&1);
+    ((int16_t*)output)[(m-m0)<<1] = nr_rx_mod_table[(NR_MOD_TABLE_QPSK_OFFSET + idx)<<1];
+    ((int16_t*)output)[((m-m0)<<1)+1] = nr_rx_mod_table[((NR_MOD_TABLE_QPSK_OFFSET + idx)<<1) + 1];
+    
 #ifdef DEBUG_PBCH
-       if (m<16)
-        {printf("nr_gold_pbch[(m<<1)>>5] %x\n",nr_gold_pbch[(m<<1)>>5]);
+    if (m<16)
+      {printf("nr_gold_pbch[(m<<1)>>5] %x\n",nr_gold_pbch[(m<<1)>>5]);
 	printf("m %d  output %d %d addr %p\n", m, ((int16_t*)output)[m<<1], ((int16_t*)output)[(m<<1)+1],&output[0]);
-	}
+      }
 #endif
-    }
-
+  }
+  
   return(0);
 }
 

openair1/PHY/NR_REFSIG/pss_nr.h

@@ -63,7 +63,7 @@
 
 /* PSS configuration */
 
-#define SYNCHRO_FFT_SIZE_MAX           (2048)                       /* maximum size of fft for synchronisation */
+#define SYNCHRO_FFT_SIZE_MAX           (8192)                       /* maximum size of fft for synchronisation */
 
 #define  NO_RATE_CHANGE                (1)
 
@@ -102,13 +102,18 @@ EXTERN int16_t *primary_synchro_nr[NUMBER_PSS_SEQUENCE]
 = { NULL, NULL, NULL}
 #endif
 ;
+EXTERN int16_t *primary_synchro_nr2[NUMBER_PSS_SEQUENCE]
+#ifdef INIT_VARIABLES_PSS_NR_H
+= { NULL, NULL, NULL}
+#endif
+;
 EXTERN int16_t *primary_synchro_time_nr[NUMBER_PSS_SEQUENCE]
 #ifdef INIT_VARIABLES_PSS_NR_H
 = { NULL, NULL, NULL}
 #endif
 ;
 
-EXTERN int *pss_corr_ue[NUMBER_PSS_SEQUENCE]
+EXTERN int64_t *pss_corr_ue[NUMBER_PSS_SEQUENCE]
 #ifdef INIT_VARIABLES_PSS_NR_H
 = { NULL, NULL, NULL}
 #endif

openair1/PHY/NR_REFSIG/refsig_defs_ue.h

@@ -29,7 +29,7 @@
 /*!\brief This function generates the NR Gold sequence (38-211, Sec 5.2.1) for the PBCH DMRS.
 @param PHY_VARS_NR_UE* ue structure provides configuration, frame parameters and the pointers to the 32 bits sequence storage tables
  */
-int nr_pbch_dmrs_rx(unsigned int *nr_gold_pbch,	int32_t *output	);
+int nr_pbch_dmrs_rx(int dmrss,unsigned int *nr_gold_pbch,	int32_t *output	);
 
 /*!\brief This function generates the NR Gold sequence (38-211, Sec 5.2.1) for the PDCCH DMRS.
 @param PHY_VARS_NR_UE* ue structure provides configuration, frame parameters and the pointers to the 32 bits sequence storage tables

openair1/PHY/NR_REFSIG/sss_nr.h

@@ -51,7 +51,7 @@
 #define  NUMBER_SSS_SEQUENCE          (336)
 #define  INVALID_SSS_SEQUENCE         (NUMBER_SSS_SEQUENCE)
 #define  LENGTH_SSS_NR                (127)
-#define  SCALING_METRIC_SSS_NR        (19)
+#define  SCALING_METRIC_SSS_NR        (15)//(19)
 
 #define  N_ID_2_NUMBER                (NUMBER_PSS_SEQUENCE)
 #define  N_ID_1_NUMBER                (NUMBER_SSS_SEQUENCE)

openair1/PHY/NR_TRANSPORT/nr_pbch.c

@@ -55,7 +55,7 @@ int nr_generate_pbch_dmrs(uint32_t *gold_pbch_dmrs,
   uint8_t idx=0;
   uint8_t nushift = config->sch_config.physical_cell_id.value &3;
 
-  LOG_I(PHY, "PBCH DMRS mapping started at symbol %d shift %d\n", ssb_start_symbol+1, nushift);
+  LOG_D(PHY, "PBCH DMRS mapping started at symbol %d shift %d\n", ssb_start_symbol+1, nushift);
 
   /// QPSK modulation
   for (int m=0; m<NR_PBCH_DMRS_LENGTH; m++) {
@@ -85,6 +85,11 @@ int nr_generate_pbch_dmrs(uint32_t *gold_pbch_dmrs,
 #endif
       ((int16_t*)txdataF[aa])[(l*frame_parms->ofdm_symbol_size + k)<<1] = (a * mod_dmrs[m<<1]) >> 15;
       ((int16_t*)txdataF[aa])[((l*frame_parms->ofdm_symbol_size + k)<<1) + 1] = (a * mod_dmrs[(m<<1) + 1]) >> 15;
+#ifdef DEBUG_PBCH_DMRS
+      printf("(%d,%d)\n",
+	((int16_t*)txdataF[aa])[(l*frame_parms->ofdm_symbol_size + k)<<1],
+	((int16_t*)txdataF[aa])[((l*frame_parms->ofdm_symbol_size + k)<<1)+1]);
+#endif
       k+=4;
 
       if (k >= frame_parms->ofdm_symbol_size)
@@ -101,6 +106,11 @@ int nr_generate_pbch_dmrs(uint32_t *gold_pbch_dmrs,
 #endif
       ((int16_t*)txdataF[aa])[(l*frame_parms->ofdm_symbol_size + k)<<1] = (a * mod_dmrs[m<<1]) >> 15;
       ((int16_t*)txdataF[aa])[((l*frame_parms->ofdm_symbol_size + k)<<1) + 1] = (a * mod_dmrs[(m<<1) + 1]) >> 15;
+#ifdef DEBUG_PBCH_DMRS
+      printf("(%d,%d)\n",
+	((int16_t*)txdataF[aa])[(l*frame_parms->ofdm_symbol_size + k)<<1],
+	((int16_t*)txdataF[aa])[((l*frame_parms->ofdm_symbol_size + k)<<1)+1]);
+#endif
       k+=(m==71)?148:4; // Jump from 44+nu to 192+nu
 
       if (k >= frame_parms->ofdm_symbol_size)
@@ -117,6 +127,11 @@ int nr_generate_pbch_dmrs(uint32_t *gold_pbch_dmrs,
 #endif
       ((int16_t*)txdataF[aa])[(l*frame_parms->ofdm_symbol_size + k)<<1] = (a * mod_dmrs[m<<1]) >> 15;
       ((int16_t*)txdataF[aa])[((l*frame_parms->ofdm_symbol_size + k)<<1) + 1] = (a * mod_dmrs[(m<<1) + 1]) >> 15;
+#ifdef DEBUG_PBCH_DMRS
+      printf("(%d,%d)\n",
+	((int16_t*)txdataF[aa])[(l*frame_parms->ofdm_symbol_size + k)<<1],
+	((int16_t*)txdataF[aa])[((l*frame_parms->ofdm_symbol_size + k)<<1)+1]);
+#endif
       k+=4;
 
       if (k >= frame_parms->ofdm_symbol_size)
@@ -218,7 +233,7 @@ int nr_generate_pbch(NR_gNB_PBCH *pbch,
   memset((void*) xbyte, 0, 1);
   //uint8_t pbch_a_b[32];
 
-  LOG_I(PHY, "PBCH generation started\n");
+  //  LOG_D(PHY, "PBCH generation started\n");
 
   memset((void*)pbch, 0, sizeof(NR_gNB_PBCH));
   ///Payload generation

openair1/PHY/NR_TRANSPORT/nr_pss.c

@@ -22,7 +22,7 @@
 
 #include "PHY/NR_TRANSPORT/nr_transport.h"
 
-#define NR_PSS_DEBUG
+//#define NR_PSS_DEBUG
 
 int nr_generate_pss(  int16_t *d_pss,
                       int32_t **txdataF,
@@ -53,6 +53,7 @@ int nr_generate_pss(  int16_t *d_pss,
 
 #ifdef NR_PSS_DEBUG
   write_output("d_pss.m", "d_pss", (void*)d_pss, NR_PSS_LENGTH, 1, 0);
+  printf("PSS: ofdm_symbol_size %d, first_carrier_offset %d\n",frame_parms->ofdm_symbol_size,frame_parms->first_carrier_offset);
 #endif
 
   /// Resource mapping
@@ -63,9 +64,12 @@ int nr_generate_pss(  int16_t *d_pss,
 
     // PSS occupies a predefined position (subcarriers 56-182, symbol 0) within the SSB block starting from
     k = frame_parms->first_carrier_offset + frame_parms->ssb_start_subcarrier + 56; //and
+    if (k>= frame_parms->ofdm_symbol_size) k-=frame_parms->ofdm_symbol_size;
+
     l = ssb_start_symbol;
 
     for (m = 0; m < NR_PSS_LENGTH; m++) {
+      //      printf("pss: writing position k %d / %d\n",k,frame_parms->ofdm_symbol_size);
       ((int16_t*)txdataF[aa])[2*(l*frame_parms->ofdm_symbol_size + k)] = (a * d_pss[m]) >> 15;
       k++;
 
@@ -75,7 +79,9 @@ int nr_generate_pss(  int16_t *d_pss,
   }
 
 #ifdef NR_PSS_DEBUG
-  write_output("pss_0.m", "pss_0", (void*)&txdataF[0][2*l*frame_parms->ofdm_symbol_size], frame_parms->ofdm_symbol_size, 1, 1);
+  LOG_M("pss_0.m", "pss_0", 
+	(void*)&txdataF[0][ssb_start_symbol*frame_parms->ofdm_symbol_size], 
+	frame_parms->ofdm_symbol_size, 1, 1);
 #endif
 
   return 0;

openair1/PHY/NR_TRANSPORT/nr_sss.c

@@ -83,7 +83,7 @@ int nr_generate_sss(  int16_t *d_sss,
     }
   }
 #ifdef NR_SSS_DEBUG
-  write_output("sss_0.m", "sss_0", (void*)txdataF[0][2*l*frame_parms->ofdm_symbol_size], frame_parms->ofdm_symbol_size, 1, 1);
+  //  write_output("sss_0.m", "sss_0", (void*)txdataF[0][l*frame_parms->ofdm_symbol_size], frame_parms->ofdm_symbol_size, 1, 1);
 #endif
 
   return 0;

openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h

@@ -46,7 +46,6 @@ int nr_pdcch_channel_estimation(PHY_VARS_NR_UE *ue,
 				uint8_t eNB_id,
 				uint8_t eNB_offset,
 				unsigned char Ns,
-				unsigned char p,
 				unsigned char l,
 				unsigned char symbol,
 				unsigned short coreset_start_subcarrier,
@@ -56,7 +55,6 @@ int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
                               uint8_t eNB_id,
                               uint8_t eNB_offset,
                               unsigned char Ns,
-                              unsigned char p,
                               unsigned char l,
                               unsigned char symbol);
 
@@ -64,7 +62,6 @@ int nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
                               uint8_t eNB_id,
                               uint8_t eNB_offset,
                               unsigned char Ns,
-                              unsigned char p,
                               unsigned char l,
                               unsigned char symbol,
 							  unsigned short bwp_start_subcarrier,

openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h

@@ -1362,6 +1362,7 @@ void generate_RIV_tables(void);
   N_RB_DL, PHICH_CONFIG and Nid_cell) and the UE can begin decoding PDCCH and DLSCH SI to retrieve the rest.  Once these
   parameters are know, the routine calls some basic initialization routines (cell-specific reference signals, etc.)
   @param phy_vars_ue Pointer to UE variables
+  @param mode current running mode
 */
 int nr_initial_sync(PHY_VARS_NR_UE *phy_vars_ue, runmode_t mode);
 

openair1/PHY/TOOLS/cdot_prod.c

@@ -158,6 +158,128 @@ int32_t dot_product(int16_t *x,
 #endif
 }
 
+int64_t dot_product64(int16_t *x,
+		      int16_t *y,
+		      uint32_t N, //must be a multiple of 8
+		      uint8_t output_shift)
+{
+
+  uint32_t n;
+
+#if defined(__x86_64__) || defined(__i386__)
+  __m128i *x128,*y128,mmtmp1,mmtmp2,mmtmp3,mmcumul,mmcumul_re,mmcumul_im;
+  __m128i minus_i = _mm_set_epi16(-1,1,-1,1,-1,1,-1,1);
+  int32_t result;
+
+  x128 = (__m128i*) x;
+  y128 = (__m128i*) y;
+
+  mmcumul_re = _mm_setzero_si128();
+  mmcumul_im = _mm_setzero_si128();
+
+  for (n=0; n<(N>>2); n++) {
+
+//    printf("n=%d, x128=%p, y128=%p\n",n,x128,y128);
+  //      print_shorts("x",&x128[0]);
+    //    print_shorts("y",&y128[0]);
+
+    // this computes Re(z) = Re(x)*Re(y) + Im(x)*Im(y)
+    mmtmp1 = _mm_madd_epi16(x128[0],y128[0]);
+      //  print_ints("retmp",&mmtmp1);
+    // mmtmp1 contains real part of 4 consecutive outputs (32-bit)
+
+    // shift and accumulate results
+    mmtmp1 = _mm_srai_epi32(mmtmp1,output_shift);
+    mmcumul_re = _mm_add_epi32(mmcumul_re,mmtmp1);
+        //print_ints("re",&mmcumul_re);
+
+
+    // this computes Im(z) = Re(x)*Im(y) - Re(y)*Im(x)
+    mmtmp2 = _mm_shufflelo_epi16(y128[0],_MM_SHUFFLE(2,3,0,1));
+        //print_shorts("y",&mmtmp2);
+    mmtmp2 = _mm_shufflehi_epi16(mmtmp2,_MM_SHUFFLE(2,3,0,1));
+        //print_shorts("y",&mmtmp2);
+    mmtmp2 = _mm_sign_epi16(mmtmp2,minus_i);
+          //  print_shorts("y",&mmtmp2);
+
+    mmtmp3 = _mm_madd_epi16(x128[0],mmtmp2);
+            //print_ints("imtmp",&mmtmp3);
+    // mmtmp3 contains imag part of 4 consecutive outputs (32-bit)
+
+    // shift and accumulate results
+    mmtmp3 = _mm_srai_epi32(mmtmp3,output_shift);
+    mmcumul_im = _mm_add_epi32(mmcumul_im,mmtmp3);
+        //print_ints("im",&mmcumul_im);
+
+    x128++;
+    y128++;
+  }
+
+  // this gives Re Re Im Im
+  mmcumul = _mm_hadd_epi32(mmcumul_re,mmcumul_im);
+    //print_ints("cumul1",&mmcumul);
+
+  // this gives Re Im Re Im
+  mmcumul = _mm_hadd_epi32(mmcumul,mmcumul);
+
+    //print_ints("cumul2",&mmcumul);
+
+
+  //mmcumul = _mm_srai_epi32(mmcumul,output_shift);
+  // extract the lower half
+  result = _mm_extract_epi64(mmcumul,0);
+  //printf("result: (%d,%d)\n",((int32_t*)&result)[0],((int32_t*)&result)[1]); 
+  _mm_empty();
+  _m_empty();
+ 
+  return(result);
+
+#elif defined(__arm__)
+  int16x4_t *x_128=(int16x4_t*)x;
+  int16x4_t *y_128=(int16x4_t*)y;
+  int32x4_t tmp_re,tmp_im;
+  int32x4_t tmp_re1,tmp_im1;
+  int32x4_t re_cumul,im_cumul;
+  int32x2_t re_cumul2,im_cumul2;
+  int32x4_t shift = vdupq_n_s32(-output_shift); 
+  int32x2x2_t result2;
+  int16_t conjug[4]__attribute__((aligned(16))) = {-1,1,-1,1} ;
+
+  re_cumul = vdupq_n_s32(0);
+  im_cumul = vdupq_n_s32(0); 
+
+  for (n=0; n<(N>>2); n++) {
+
+    tmp_re  = vmull_s16(*x_128++, *y_128++);
+    //tmp_re = [Re(x[0])Re(y[0]) Im(x[0])Im(y[0]) Re(x[1])Re(y[1]) Im(x[1])Im(y[1])] 
+    tmp_re1 = vmull_s16(*x_128++, *y_128++);
+    //tmp_re1 = [Re(x1[1])Re(x2[1]) Im(x1[1])Im(x2[1]) Re(x1[1])Re(x2[2]) Im(x1[1])Im(x2[2])] 
+    tmp_re  = vcombine_s32(vpadd_s32(vget_low_s32(tmp_re),vget_high_s32(tmp_re)),
+                           vpadd_s32(vget_low_s32(tmp_re1),vget_high_s32(tmp_re1)));
+    //tmp_re = [Re(ch[0])Re(rx[0])+Im(ch[0])Im(ch[0]) Re(ch[1])Re(rx[1])+Im(ch[1])Im(ch[1]) Re(ch[2])Re(rx[2])+Im(ch[2]) Im(ch[2]) Re(ch[3])Re(rx[3])+Im(ch[3])Im(ch[3])] 
+
+    tmp_im  = vmull_s16(vrev32_s16(vmul_s16(*x_128++,*(int16x4_t*)conjug)),*y_128++);
+    //tmp_im = [-Im(ch[0])Re(rx[0]) Re(ch[0])Im(rx[0]) -Im(ch[1])Re(rx[1]) Re(ch[1])Im(rx[1])]
+    tmp_im1 = vmull_s16(vrev32_s16(vmul_s16(*x_128++,*(int16x4_t*)conjug)),*y_128++);
+    //tmp_im1 = [-Im(ch[2])Re(rx[2]) Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3]) Re(ch[3])Im(rx[3])]
+    tmp_im  = vcombine_s32(vpadd_s32(vget_low_s32(tmp_im),vget_high_s32(tmp_im)),
+                           vpadd_s32(vget_low_s32(tmp_im1),vget_high_s32(tmp_im1)));
+    //tmp_im = [-Im(ch[0])Re(rx[0])+Re(ch[0])Im(rx[0]) -Im(ch[1])Re(rx[1])+Re(ch[1])Im(rx[1]) -Im(ch[2])Re(rx[2])+Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3])+Re(ch[3])Im(rx[3])]
+
+    re_cumul = vqaddq_s32(re_cumul,vqshlq_s32(tmp_re,shift));
+    im_cumul = vqaddq_s32(im_cumul,vqshlq_s32(tmp_im,shift));
+  }
+  
+  re_cumul2 = vpadd_s32(vget_low_s32(re_cumul),vget_high_s32(re_cumul));
+  im_cumul2 = vpadd_s32(vget_low_s32(im_cumul),vget_high_s32(im_cumul));
+  re_cumul2 = vpadd_s32(re_cumul2,re_cumul2);
+  im_cumul2 = vpadd_s32(im_cumul2,im_cumul2);
+  result2   = vzip_s32(re_cumul2,im_cumul2);
+  return(vget_lane_s32(result2.val[0],0));
+#endif
+}
+
+
 
 #ifdef MAIN
 void print_bytes(char *s,__m128i *x)

openair1/PHY/TOOLS/dB_routines.c

@@ -624,6 +624,14 @@ int8_t dB_fixed(uint32_t x)
   return dB_power;
 }
 
+uint8_t dB_fixed64(uint64_t x)
+{
+
+  if (x<(((uint64_t)1)<<32)) return(dB_fixed((uint32_t)x));
+  else                       return(4*dB_table[255] + dB_fixed(x>>32)); 
+ 
+}
+
 int8_t dB_fixed2(uint32_t x, uint32_t y)
 {
 

openair1/PHY/TOOLS/lte_dfts.c

@@ -74,7 +74,7 @@ static inline void cmac(__m128i a,__m128i b, __m128i *re32, __m128i *im32)
   cmac_tmp    = _mm_sign_epi16(b,*(__m128i*)reflip);
   cmac_tmp_re32  = _mm_madd_epi16(a,cmac_tmp);
 
-
+ 
   //  cmac_tmp    = _mm_shufflelo_epi16(b,_MM_SHUFFLE(2,3,0,1));
   //  cmac_tmp    = _mm_shufflehi_epi16(cmac_tmp,_MM_SHUFFLE(2,3,0,1));
   cmac_tmp = _mm_shuffle_epi8(b,_mm_set_epi8(13,12,15,14,9,8,11,10,5,4,7,6,1,0,3,2));
@@ -4464,6 +4464,7 @@ void dft2048(int16_t *x,int16_t *y,int scale)
   _mm_empty();
   _m_empty();
 
+
 }
 
 void idft2048(int16_t *x,int16_t *y,int scale)
@@ -4567,6 +4568,7 @@ void dft2048(int16_t *x,int16_t *y,int scale)
   int i;
   simd256_q15_t ONE_OVER_SQRT2_Q15_128 = set1_int16_simd256(ONE_OVER_SQRT2_Q15);
 
+
   xtmpp = xtmp;
 
   for (i=0; i<4; i++) {
@@ -4658,7 +4660,7 @@ void idft2048(int16_t *x,int16_t *y,int scale)
   simd256_q15_t ONE_OVER_SQRT2_Q15_128 = set1_int16_simd256(ONE_OVER_SQRT2_Q15);
 
   xtmpp = xtmp;
-
+  
   for (i=0; i<4; i++) {
     transpose4_ooff_simd256(x256  ,xtmpp,128);
     transpose4_ooff_simd256(x256+2,xtmpp+1,128);
@@ -4801,7 +4803,7 @@ void dft4096(int16_t *x,int16_t *y,int scale)
 
 }
 
-
+ 
 
 void idft4096(int16_t *x,int16_t *y,int scale)
 {
@@ -4851,7 +4853,7 @@ void idft4096(int16_t *x,int16_t *y,int scale)
 
       y128+=16;
     }
-
+ 
   }
 
   _mm_empty();

openair1/PHY/TOOLS/tools_defs.h

@@ -350,6 +350,11 @@ int32_t dot_product(int16_t *x,
                     uint32_t N, //must be a multiple of 8
                     uint8_t output_shift);
 
+int64_t dot_product64(int16_t *x,
+		      int16_t *y,
+		      uint32_t N, //must be a multiple of 8
+		      uint8_t output_shift);
+
 void dft12(int16_t *x,int16_t *y);
 void dft24(int16_t *x,int16_t *y,uint8_t scale_flag);
 void dft36(int16_t *x,int16_t *y,uint8_t scale_flag);

openair1/PHY/defs_nr_UE.h

@@ -920,6 +920,7 @@ typedef struct {
   /// - 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;
+  int log2_maxh;
   uint8_t pbch_a[NR_POLAR_PBCH_PAYLOAD_BITS>>3];
   uint32_t pbch_a_interleaved;
   uint32_t pbch_a_prime;
@@ -1061,7 +1062,7 @@ typedef struct {
   uint32_t dmrs_pbch_bitmap_nr[DMRS_PBCH_I_SSB][DMRS_PBCH_N_HF][DMRS_BITMAP_SIZE];
 
 #endif
-  t_nrPolar_paramsPtr nrPolar_params;
+  t_nrPolar_params  *nrPolar_params;
 
   /// PBCH DMRS sequence
   uint32_t nr_gold_pbch[2][64][NR_PBCH_DMRS_LENGTH_DWORD];
@@ -1129,6 +1130,8 @@ typedef struct {
   //  uint8_t               prach_timer;
   uint8_t               decode_SIB;
   uint8_t               decode_MIB;
+  /// temporary offset during cell search prior to MIB decoding
+  int              ssb_offset;
   int              rx_offset; /// Timing offset
   int              rx_offset_diff; /// Timing adjustment for ofdm symbol0 on HW USRP
   int              time_sync_cell;

openair1/PHY/defs_nr_common.h

@@ -160,10 +160,14 @@ typedef struct {
 typedef struct NR_DL_FRAME_PARMS {
   /// frequency range
   nr_frequency_range_e freq_range;
+  /// Placeholder to replace overlapping fields below
+  nfapi_nr_rf_config_t rf_config;
+  /// Placeholder to replace SSB overlapping fields below
+  nfapi_nr_sch_config_t sch_config;
   /// Number of resource blocks (RB) in DL
-  uint8_t N_RB_DL;
+  int N_RB_DL;
   /// Number of resource blocks (RB) in UL
-  uint8_t N_RB_UL;
+  int N_RB_UL;
   ///  total Number of Resource Block Groups: this is ceil(N_PRB/P)
   uint8_t N_RBG;
   /// Total Number of Resource Block Groups SubSets: this is P

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -111,9 +111,9 @@ int nr_get_ssb_start_symbol(nfapi_nr_config_request_t *cfg, NR_DL_FRAME_PARMS *f
 
 void nr_set_ssb_first_subcarrier(nfapi_nr_config_request_t *cfg, NR_DL_FRAME_PARMS *fp)
 {
-  int start_rb = cfg->sch_config.n_ssb_crb.value / pow(2,cfg->subframe_config.numerology_index_mu.value);
+  int start_rb = cfg->sch_config.n_ssb_crb.value / (1<<cfg->subframe_config.numerology_index_mu.value);
   fp->ssb_start_subcarrier = 12 * start_rb + cfg->sch_config.ssb_subcarrier_offset.value;
-  LOG_D(PHY, "SSB first subcarrier %d\n", fp->ssb_start_subcarrier);
+  LOG_D(PHY, "SSB first subcarrier %d (%d,%d)\n", fp->ssb_start_subcarrier,start_rb,cfg->sch_config.ssb_subcarrier_offset.value);
 }
 
 void nr_common_signal_procedures (PHY_VARS_gNB *gNB,int frame, int subframe) {
@@ -135,12 +135,13 @@ void nr_common_signal_procedures (PHY_VARS_gNB *gNB,int frame, int subframe) {
   if (subframe == ss_subframe)
   {
     // Current implementation is based on SSB in first half frame, first candidate
-    LOG_I(PHY,"SS TX: frame %d, subframe %d, start_symbol %d\n",frame,subframe, ssb_start_symbol);
+    LOG_D(PHY,"SS TX: frame %d, subframe %d, start_symbol %d\n",frame,subframe, ssb_start_symbol);
 
     nr_generate_pss(gNB->d_pss, txdataF, AMP, ssb_start_symbol, cfg, fp);
     nr_generate_sss(gNB->d_sss, txdataF, AMP_OVER_2, ssb_start_symbol, cfg, fp);
 
     if (!(frame&7)){
+      LOG_D(PHY,"%d.%d : pbch_configured %d\n",frame,subframe,gNB->pbch_configured);
       if (gNB->pbch_configured != 1)return;
       gNB->pbch_configured = 0;
     }
@@ -182,7 +183,7 @@ void phy_procedures_gNB_TX(PHY_VARS_gNB *gNB,
 
   num_dci = gNB->pdcch_vars.num_dci;
   if (num_dci) {
-    LOG_I(PHY, "[gNB %d] Frame %d subframe %d \
+    LOG_D(PHY, "[gNB %d] Frame %d subframe %d \
     Calling nr_generate_dci_top (number of DCI %d)\n", gNB->Mod_id, frame, subframe, num_dci);
 
     uint8_t slot_idx = gNB->pdcch_vars.dci_alloc[0].pdcch_params.first_slot;

openair1/SIMULATION/NR_PHY/pbchsim.c

@@ -101,13 +101,12 @@ int main(int argc, char **argv)
   char input_val_str[50],input_val_str2[50];
 
   uint8_t frame_mod4,num_pdcch_symbols = 0;
-  uint16_t NB_RB=25;
 
   SCM_t channel_model=AWGN;//Rayleigh1_anticorr;
 
   double pbch_sinr;
   int pbch_tx_ant;
-  uint8_t N_RB_DL=106,mu=1;
+  int N_RB_DL=273,mu=1;
 
   unsigned char frame_type = 0;
   unsigned char pbch_phase = 0;
@@ -119,7 +118,8 @@ int main(int argc, char **argv)
   nfapi_nr_config_request_t *gNB_config;
 
   int ret;
-  
+  int run_initial_sync=0;
+
   cpuf = get_cpu_freq_GHz();
 
   if ( load_configmodule(argc,argv) == 0) {
@@ -129,7 +129,7 @@ int main(int argc, char **argv)
   logInit();
   randominit(0);
 
-  while ((c = getopt (argc, argv, "f:hA:pf:g:i:j:n:s:S:t:x:y:z:N:F:GR:dP:")) != -1) {
+  while ((c = getopt (argc, argv, "f:hA:pf:g:i:j:n:s:S:t:x:y:z:N:F:GR:dP:I")) != -1) {
     switch (c) {
     case 'f':
       write_output_file=1;
@@ -281,7 +281,10 @@ int main(int argc, char **argv)
         printf("Illegal PBCH phase (0-3) got %d\n",pbch_phase);
 
       break;
-
+      
+    case 'I':
+      run_initial_sync=1;
+      break;
     default:
     case 'h':
       printf("%s -h(elp) -p(extended_prefix) -N cell_id -f output_filename -F input_filename -g channel_model -n n_frames -t Delayspread -s snr0 -S snr1 -x transmission_mode -y TXant -z RXant -i Intefrence0 -j Interference1 -A interpolation_file -C(alibration offset dB) -N CellId\n",
@@ -314,19 +317,8 @@ int main(int argc, char **argv)
   if (snr1set==0)
     snr1 = snr0+10;
 
-  gNB2UE = new_channel_desc_scm(n_tx,
-                                n_rx,
-                                channel_model,
- 				61.44e6, //N_RB2sampling_rate(N_RB_DL),
-				40e6, //N_RB2channel_bandwidth(N_RB_DL),
-                                0,
-                                0,
-                                0);
 
-  if (gNB2UE==NULL) {
-    msg("Problem generating channel model. Exiting.\n");
-    exit(-1);
-  }
+  printf("Initializing gNodeB for mu %d, N_RB_DL %d\n",mu,N_RB_DL);
 
   RC.gNB = (PHY_VARS_gNB***) malloc(sizeof(PHY_VARS_gNB **));
   RC.gNB[0] = (PHY_VARS_gNB**) malloc(sizeof(PHY_VARS_gNB *));
@@ -337,10 +329,45 @@ int main(int argc, char **argv)
   frame_parms->nb_antennas_tx = n_tx;
   frame_parms->nb_antennas_rx = n_rx;
   frame_parms->N_RB_DL = N_RB_DL;
+  frame_parms->N_RB_UL = N_RB_DL;
 
-  nr_phy_config_request_sim(gNB);
+  nr_phy_config_request_sim(gNB,N_RB_DL,N_RB_DL,mu);
   phy_init_nr_gNB(gNB,0,0);
 
+  double fs,bw;
+
+  if (mu == 1 && N_RB_DL == 217) { 
+    fs = 122.88e6;
+    bw = 80e6;
+  }					       
+  else if (mu == 1 && N_RB_DL == 245) {
+    fs = 122.88e6;
+    bw = 90e6;
+  }
+  else if (mu == 1 && N_RB_DL == 273) {
+    fs = 122.88e6;
+    bw = 100e6;
+  }
+  else if (mu == 1 && N_RB_DL == 106) { 
+    fs = 61.44e6;
+    bw = 40e6;
+  }
+  else AssertFatal(1==0,"Unsupported numerology for mu %d, N_RB %d\n",mu, N_RB_DL);
+
+  gNB2UE = new_channel_desc_scm(n_tx,
+                                n_rx,
+                                channel_model,
+ 				fs, 
+				bw, 
+                                0,
+                                0,
+                                0);
+
+  if (gNB2UE==NULL) {
+    msg("Problem generating channel model. Exiting.\n");
+    exit(-1);
+  }
+
   frame_length_complex_samples = frame_parms->samples_per_subframe;
   frame_length_complex_samples_no_prefix = frame_parms->samples_per_subframe_wCP;
 
@@ -362,6 +389,7 @@ int main(int argc, char **argv)
     r_im[i] = malloc(frame_length_complex_samples*sizeof(double));
     bzero(r_im[i],frame_length_complex_samples*sizeof(double));
 
+    printf("Allocating %d samples for txdata\n",frame_length_complex_samples);
     txdata[i] = malloc(frame_length_complex_samples*sizeof(int));
     bzero(r_re[i],frame_length_complex_samples*sizeof(int));
   
@@ -375,23 +403,31 @@ int main(int argc, char **argv)
   //configure UE
   UE = malloc(sizeof(PHY_VARS_NR_UE));
   memcpy(&UE->frame_parms,frame_parms,sizeof(NR_DL_FRAME_PARMS));
-  phy_init_nr_top(frame_parms);
+  phy_init_nr_top(UE);
+  if (run_initial_sync==1)  UE->is_synchronized = 0;
+  else                      UE->is_synchronized = 1;
+                      
+  UE->perfect_ce = 0;
+
   if (init_nr_ue_signal(UE, 1, 0) != 0)
   {
     printf("Error at UE NR initialisation\n");
     exit(-1);
   }
 
-
+  nr_gold_pbch(UE);
   // generate signal
   if (input_fd==NULL) {
+    gNB->pbch_configured = 1;
+    for (int i=0;i<4;i++) gNB->pbch_pdu[i]=i+1;
     nr_common_signal_procedures (gNB,frame,subframe);
   }
 
+  /*  
   LOG_M("txsigF0.m","txsF0", gNB->common_vars.txdataF[0],frame_length_complex_samples_no_prefix,1,1);
   if (gNB->frame_parms.nb_antennas_tx>1)
     LOG_M("txsigF1.m","txsF1", gNB->common_vars.txdataF[1],frame_length_complex_samples_no_prefix,1,1);
-
+  */
   //TODO: loop over slots
   for (aa=0; aa<gNB->frame_parms.nb_antennas_tx; aa++) {
     if (gNB_config->subframe_config.dl_cyclic_prefix_type.value == 1) {
@@ -408,18 +444,22 @@ int main(int argc, char **argv)
 			   frame_parms);
     }
   }
-
+  /*
   LOG_M("txsig0.m","txs0", txdata[0],frame_length_complex_samples,1,1);
   if (gNB->frame_parms.nb_antennas_tx>1)
     LOG_M("txsig1.m","txs1", txdata[1],frame_length_complex_samples,1,1);
+  */
+  int txlev = signal_energy(&txdata[0][5*frame_parms->ofdm_symbol_size + 4*frame_parms->nb_prefix_samples + frame_parms->nb_prefix_samples0],
+			    frame_parms->ofdm_symbol_size + frame_parms->nb_prefix_samples);
 
+  //  printf("txlev %d (%f)\n",txlev,10*log10(txlev));
 
   for (i=0; i<frame_length_complex_samples; i++) {
     for (aa=0; aa<frame_parms->nb_antennas_tx; aa++) {
       r_re[aa][i] = ((double)(((short *)txdata[aa]))[(i<<1)]);
       r_im[aa][i] = ((double)(((short *)txdata[aa]))[(i<<1)+1]);
-      }
     }
+  }
   
   for (SNR=snr0; SNR<snr1; SNR+=.2) {
 
@@ -433,13 +473,15 @@ int main(int argc, char **argv)
       //multipath_channel(gNB2UE,s_re,s_im,r_re,r_im,frame_length_complex_samples,0);
       
       //AWGN
-      sigma2_dB = SNR;
+      sigma2_dB = 10*log10((double)txlev)-SNR;
       sigma2 = pow(10,sigma2_dB/10);
+      //      printf("sigma2 %f (%f dB)\n",sigma2,sigma2_dB);
+
       for (i=0; i<frame_length_complex_samples; i++) {
 	for (aa=0; aa<frame_parms->nb_antennas_rx; aa++) {
 	  
-	  ((short*) UE->common_vars.rxdata[aa])[2*i] = (short) ((r_re[aa][i] +sqrt(sigma2/2)*gaussdouble(0.0,1.0)));
-	  ((short*) UE->common_vars.rxdata[aa])[2*i+1] = (short) ((r_im[aa][i] + (iqim*r_re[aa][i]) + sqrt(sigma2/2)*gaussdouble(0.0,1.0)));
+	  ((short*) UE->common_vars.rxdata[aa])[2*i]   = (short) ((r_re[aa][i] + sqrt(sigma2/2)*gaussdouble(0.0,1.0)));
+	  ((short*) UE->common_vars.rxdata[aa])[2*i+1] = (short) ((r_im[aa][i] + sqrt(sigma2/2)*gaussdouble(0.0,1.0)));
 	}
       }
 
@@ -448,13 +490,53 @@ int main(int argc, char **argv)
 	if (gNB->frame_parms.nb_antennas_tx>1)
 	  LOG_M("rxsig1.m","rxs1", UE->common_vars.rxdata[1],frame_length_complex_samples,1,1);
       }
-
-      ret = nr_initial_sync(UE, normal_txrx);
-      printf("nr_initial_sync1 returns %d\n",ret);
-      
+      if (UE->is_synchronized == 0) {
+	ret = nr_initial_sync(UE, normal_txrx);
+	printf("nr_initial_sync1 returns %d\n",ret);
+	if (ret<0) n_errors++;
+      }
+      else {
+	UE->rx_offset=0;
+	//symbol 1
+	nr_slot_fep(UE,
+		    5,
+		    0,
+		    0,
+		    0,
+		    1,
+		    NR_PBCH_EST);
+	
+	//symbol 2
+	nr_slot_fep(UE,
+		    6,
+		    0,
+		    0,
+		    0,
+		    1,
+		    NR_PBCH_EST);
+	
+	//symbol 3
+	nr_slot_fep(UE,
+		    7,
+		    0,
+		    0,
+		    0,
+		    1,
+		    NR_PBCH_EST);
+	
+	ret = nr_rx_pbch(UE,
+			 &UE->proc.proc_rxtx[0],
+			 UE->pbch_vars[0],
+			 frame_parms,
+			 0,
+			 SISO,
+			 UE->high_speed_flag);
+
+	if (ret<0) n_errors++;
+      }
     } //noise trials
 
-    printf("SNR %f : n_errors = %d/%d\n", SNR,n_errors,n_trials);
+    printf("SNR %f : n_errors (negative CRC) = %d/%d\n", SNR,n_errors,n_trials);
 
     if (n_trials==1)
       break;