merging in develop-nr and resolving conficts

ci-scripts/main.py

@@ -2542,14 +2542,19 @@ elif re.match('^InitiateHtml$', mode, re.IGNORECASE):
 		Usage()
 		sys.exit('Insufficient Parameter')
 	count = 0
+	foundCount = 0
 	while (count < SSH.nbTestXMLfiles):
 		xml_test_file = sys.path[0] + "/" + SSH.testXMLfiles[count]
-		xmlTree = ET.parse(xml_test_file)
-		xmlRoot = xmlTree.getroot()
-		SSH.htmlTabRefs.append(xmlRoot.findtext('htmlTabRef',default='test-tab-' + str(count)))
-		SSH.htmlTabNames.append(xmlRoot.findtext('htmlTabName',default='Test-' + str(count)))
-		SSH.htmlTabIcons.append(xmlRoot.findtext('htmlTabIcon',default='info-sign'))
+		if (os.path.isfile(xml_test_file)):
+			xmlTree = ET.parse(xml_test_file)
+			xmlRoot = xmlTree.getroot()
+			SSH.htmlTabRefs.append(xmlRoot.findtext('htmlTabRef',default='test-tab-' + str(count)))
+			SSH.htmlTabNames.append(xmlRoot.findtext('htmlTabName',default='Test-' + str(count)))
+			SSH.htmlTabIcons.append(xmlRoot.findtext('htmlTabIcon',default='info-sign'))
+			foundCount += 1
 		count += 1
+	if foundCount != SSH.nbTestXMLfiles:
+		SSH.nbTestXMLfiles = foundCount
 	SSH.CreateHtmlHeader()
 elif re.match('^FinalizeHtml$', mode, re.IGNORECASE):
 	SSH.CreateHtmlFooter(SSH.finalStatus)

cmake_targets/CMakeLists.txt

@@ -167,7 +167,7 @@ endif()
 
 #
 set(CMAKE_C_FLAGS
-  "${CMAKE_C_FLAGS} ${C_FLAGS_PROCESSOR} -std=gnu99 -Wall -Wstrict-prototypes -fno-strict-aliasing -rdynamic -funroll-loops -Wno-packed-bitfield-compat -fPIC ")
+  "${CMAKE_C_FLAGS} ${C_FLAGS_PROCESSOR} -std=gnu99 -Wall -Wstrict-prototypes -fno-strict-aliasing -rdynamic -funroll-loops -Wno-packed-bitfield-compat -fPIC")
 # add autotools definitions that were maybe used!
 set(MKVER "'MAKE_VERSION(a,b,c)=((a)*256+(b)*16+c)'")
 set(CMAKE_C_FLAGS
@@ -1575,6 +1575,7 @@ add_library(L2
   ${ENB_APP_SRC}
   )
 add_dependencies(L2 rrc_flag s1ap_flag x2_flag)
+
 add_library(MAC_NR
   ${MAC_NR_SRC}
   )
@@ -1593,7 +1594,6 @@ add_dependencies(S1AP_LIB nr_rrc_flag s1ap_flag)
 add_library(L2_UE
   ${L2_SRC_UE}
   ${MAC_SRC_UE}
-  #${MAC_NR_SRC_UE}
 )
 if (NOT ${NOS1})
 target_compile_definitions(L2_UE PUBLIC -DPDCP_USE_NETLINK)
@@ -1602,44 +1602,13 @@ endif()
 add_dependencies(L2_UE rrc_flag s1ap_flag x2_flag)
 
 add_library( NR_L2_UE
-    #${L2_SRC_UE}
     ${NR_L2_SRC_UE}
     ${MAC_NR_SRC_UE}
-    #${MAC_SRC_UE}
-)
-
-set ( NR_LTE_UE_REUSE_SRC
-  ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_sync_timefreq.c
-  ${OPENAIR1_DIR}/SCHED/phy_procedures_lte_common.c
-  #${OPENAIR1_DIR}/SCHED_UE/phy_procedures_lte_ue.c
-  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/lte_mcs.c
-  #${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/pmch_common.c
-
-  #${OPENAIR1_DIR}/PHY/LTE_REFSIG/lte_dl_cell_spec.c
-  #${OPENAIR1_DIR}/PHY/CODING/lte_segmentation.c
-  #${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/prach_common.c
-#  ${OPENAIR1_DIR}/PHY/INIT/lte_init_ue.c
-  ${OPENAIR1_DIR}/PHY/CODING/crc_byte.c
-  ${OPENAIR1_DIR}/PHY/CODING/viterbi_lte.c
-  ${OPENAIR1_DIR}/PHY/CODING/viterbi.c
-  #${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/phich_common.c
-  ${OPENAIR1_DIR}/PHY/LTE_UE_TRANSPORT/dlsch_llr_computation.c
-
-#  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dci_tools_common.c
-#  ${OPENAIR1_DIR}/PHY/CODING/lte_rate_matching.c
-  ${OPENAIR1_DIR}/PHY/CODING/ccoding_byte_lte.c
-  ${OPENAIR1_DIR}/PHY/CODING/ccoding_byte.c
-  ${OPENAIR1_DIR}/PHY/LTE_REFSIG/lte_gold.c
-  ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_est_freq_offset.c
-  ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_dl_channel_estimation.c
-  ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_ue_measurements.c
-  #${OPENAIR1_DIR}/PHY/LTE_UE_TRANSPORT/dlsch_demodulation.c
-  #${OPENAIR1_DIR}/PHY/LTE_UE_TRANSPORT/dlsch_llr_computation_avx2.c
-)
-
-add_library( NR_LTE_UE_REUSE_LIB
-    ${NR_LTE_UE_REUSE_SRC}
-)
+    )
+  
+add_library( MAC_NR_COMMON
+  ${OPENAIR2_DIR}/LAYER2/NR_MAC_gNB/nr_mac_common.c
+  )
 
 include_directories("${OPENAIR2_DIR}/NR_UE_PHY_INTERFACE")
 include_directories("${OPENAIR2_DIR}/LAYER2/NR_MAC_UE")
@@ -2368,7 +2337,7 @@ target_link_libraries (nr-softmodem
   -Wl,--start-group
   UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB SCHED_RU_LIB SCHED_NR_LIB PHY_NR PHY PHY_COMMON PHY_RU LFDS GTPV1U SECU_CN SECU_OSA
   ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} ${FLEXRAN_AGENT_LIB} LFDS7 ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB}
-  RRC_LIB NR_RRC_LIB S1AP_LIB S1AP_ENB L2 L2_NR
+  RRC_LIB NR_RRC_LIB S1AP_LIB S1AP_ENB L2 L2_NR MAC_NR_COMMON
   NFAPI_COMMON_LIB NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB NFAPI_USER_LIB
   -Wl,--end-group z dl)
 
@@ -2409,7 +2378,7 @@ target_link_libraries (nr-softmodem-nos1
   -Wl,--start-group
   UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB SCHED_RU_LIB SCHED_NR_LIB PHY_NR PHY PHY_COMMON PHY_RU LFDS GTPV1U SECU_CN SECU_OSA
   ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} ${FLEXRAN_AGENT_LIB} LFDS7 ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} ${MIH_LIB}
-  RRC_LIB NR_RRC_LIB S1AP_LIB S1AP_ENB L2 L2_NR
+  RRC_LIB NR_RRC_LIB S1AP_LIB S1AP_ENB L2 L2_NR MAC_NR_COMMON
   NFAPI_COMMON_LIB NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB NFAPI_USER_LIB
   -Wl,--end-group z dl)
 
@@ -2444,7 +2413,7 @@ add_executable(nr-uesoftmodem
 
 target_link_libraries (nr-uesoftmodem
   -Wl,--start-group
-  RRC_LIB NR_RRC_LIB SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT UDP SCHED_RU_LIB SCHED_UE_LIB SCHED_NR_UE_LIB PHY_COMMON PHY_NR_UE PHY_RU LFDS NR_L2_UE #NR_LTE_UE_REUSE_LIB 
+  RRC_LIB NR_RRC_LIB SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT UDP SCHED_RU_LIB SCHED_UE_LIB SCHED_NR_UE_LIB PHY_COMMON PHY_NR_UE PHY_RU LFDS NR_L2_UE  MAC_NR_COMMON
   ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} LFDS7 ${ATLAS_LIBRARIES}
   -Wl,--end-group z dl)
 
@@ -2478,7 +2447,7 @@ add_executable(nr-uesoftmodem-nos1
 
 target_link_libraries (nr-uesoftmodem-nos1
   -Wl,--start-group
-  RRC_LIB NR_RRC_LIB S1AP_LIB S1AP_ENB GTPV1U SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT UDP SCHED_RU_LIB SCHED_UE_LIB SCHED_NR_UE_LIB PHY_COMMON PHY_NR_UE PHY_UE PHY_RU LFDS NR_L2_UE 
+  RRC_LIB NR_RRC_LIB S1AP_LIB S1AP_ENB GTPV1U SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT UDP SCHED_RU_LIB SCHED_UE_LIB SCHED_NR_UE_LIB PHY_COMMON PHY_NR_UE PHY_UE PHY_RU LFDS NR_L2_UE MAC_NR_COMMON
   ${MSC_LIB} ${RAL_LIB} ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} LFDS7 ${ATLAS_LIBRARIES}
   -Wl,--end-group z dl)
 
@@ -2555,7 +2524,7 @@ add_executable(nr_dlsim
   ${OPENAIR1_DIR}/SIMULATION/NR_PHY/dlsim.c 
   ${OPENAIR_DIR}/common/utils/backtrace.c
   ${T_SOURCE})   
-target_link_libraries(nr_dlsim  -Wl,--start-group UTIL SIMU PHY_COMMON PHY_NR PHY_NR_UE SCHED_NR_LIB SCHED_NR_UE_LIB MAC_NR MAC_UE_NR RRC_LIB NR_RRC_LIB CONFIG_LIB L2_NR -Wl,--end-group m pthread ${ATLAS_LIBRARIES} ${T_LIB} dl)
+target_link_libraries(nr_dlsim  -Wl,--start-group UTIL SIMU PHY_COMMON PHY_NR PHY_NR_UE SCHED_NR_LIB SCHED_NR_UE_LIB MAC_NR MAC_UE_NR MAC_NR_COMMON RRC_LIB NR_RRC_LIB CONFIG_LIB L2_NR -Wl,--end-group m pthread ${ATLAS_LIBRARIES} ${T_LIB} dl)
 
 
 foreach(myExe dlsim dlsim_tm7 ulsim pbchsim scansim mbmssim pdcchsim pucchsim prachsim syncsim)
@@ -2688,7 +2657,9 @@ L2
 L2_NR
 L2_UE
 NR_L2_UE
-NR_LTE_UE_REUSE_LIB
+MAC_NR_COMMON
+MAC_NR
+MAC_UE_NR
 CN_UTILS
 GTPV1U
 SCTP_CLIENT

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c

@@ -54,7 +54,7 @@ int32_t nrLDPC_decoder(t_nrLDPC_dec_params* p_decParams, int8_t* p_llr, int8_t*
     t_nrLDPC_lut lut;
     t_nrLDPC_lut* p_lut = &lut;
 
-    printf("p_procBuf->cnProcBuf = %p\n", p_procBuf->cnProcBuf);
+    //printf("p_procBuf->cnProcBuf = %p\n", p_procBuf->cnProcBuf);
 
     // Initialize decoder core(s) with correct LUTs
     numLLR = nrLDPC_init(p_decParams, p_lut);

openair1/PHY/CODING/nrPolar_tools/nr_polar_decoding_tools.c

@@ -525,7 +525,7 @@ void computeBeta(t_nrPolar_params *pp,decoder_node_t *node) {
   
 }
 
-void generic_polar_decoder(t_nrPolar_params *pp,decoder_node_t *node) {
+void generic_polar_decoder(const t_nrPolar_params *pp,decoder_node_t *node) {
 
 
   // Apply F to left

openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h

@@ -184,7 +184,7 @@ int8_t polar_decoder_dci(double *input,
                          uint8_t pathMetricAppr,
                          uint16_t n_RNTI);
 
-void generic_polar_decoder(t_nrPolar_params *,
+void generic_polar_decoder(const t_nrPolar_params *,
                            decoder_node_t *);
 
 void build_decoder_tree(t_nrPolar_params *pp);

openair1/PHY/CODING/nr_rate_matching.c

@@ -182,6 +182,7 @@ int nr_rate_matching_ldpc_rx(uint8_t Ilbrm,
 #endif
   }
 
+  if (rvidx !=0){
   while(k<E) {
     for (ind=0; (ind<Ncb)&&(k<E); ind++) {
       if (soft_input[ind] != NR_NULL) {
@@ -200,6 +201,7 @@ int nr_rate_matching_ldpc_rx(uint8_t Ilbrm,
 #endif
     }
   }
+  }
 
   return 0;
 }

openair1/PHY/CODING/nr_segmentation.c

@@ -156,7 +156,7 @@ else
 
       if (*F>0) {
         for (k=Kprime>>3; k<(*K)>>3; k++) {
-          output_buffers[r][k] = NR_NULL;
+          output_buffers[r][k] = 0;
           //printf("r %d filler bits [%d] = %d Kprime %d \n", r,k, output_buffers[r][k], Kprime);
         }
       }

openair1/PHY/INIT/nr_parms.c

@@ -300,3 +300,6 @@ void nr_dump_frame_parms(NR_DL_FRAME_PARMS *fp)
   LOG_I(PHY,"fp->initial_bwp_dl.location=%d\n",fp->initial_bwp_dl.location);
   LOG_I(PHY,"fp->initial_bwp_dl.ofdm_symbol_size=%d\n",fp->initial_bwp_dl.ofdm_symbol_size);
 }
+
+
+

openair1/PHY/INIT/phy_init.h

@@ -391,6 +391,7 @@ void init_nr_transport(PHY_VARS_gNB *gNB);
 
 void init_dfts(void);
 
+
 /** @} */
 #endif
 

openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c

@@ -277,17 +277,18 @@ int nr_dlsch_encoding(unsigned char *a,
   nfapi_nr_dl_config_dlsch_pdu_rel15_t rel15 = dlsch->harq_processes[harq_pid]->dlsch_pdu.dlsch_pdu_rel15;
   uint16_t nb_rb = rel15.n_prb;
   uint8_t nb_symb_sch = rel15.nb_symbols;
-  uint32_t A, Z;
+  uint32_t A, Z, F=0;
   uint32_t *pz = &Z;
   uint8_t mod_order = rel15.modulation_order;
   uint16_t Kr=0,r,r_offset=0,Kr_bytes;
   uint8_t *d_tmp[MAX_NUM_DLSCH_SEGMENTS];
-  uint8_t kb,BG=1;
+  uint8_t BG=1;
   uint32_t E;
   uint8_t Ilbrm = 0;
   uint32_t Tbslbrm = 950984; //max tbs
   uint8_t nb_re_dmrs = rel15.nb_re_dmrs;
   uint16_t length_dmrs = 1;
+  float Coderate = 0.0;
 
   /*
   uint8_t *channel_input[MAX_NUM_DLSCH_SEGMENTS]; //unsigned char
@@ -337,18 +338,20 @@ int nr_dlsch_encoding(unsigned char *a,
 		    pz,
 		    &dlsch->harq_processes[harq_pid]->F);
 
-    kb = dlsch->harq_processes[harq_pid]->K/(*pz);
-    if ( kb==22){
-		BG = 1;
+    F = dlsch->harq_processes[harq_pid]->F;
+    Coderate = (float) A /(float) G;
+
+    if ((A <=292) || ((A<=3824) && (Coderate <= 0.6667)) || Coderate <= 0.25){
+		BG = 2;
 	}
 	else{
-		BG = 2;
+		BG = 1;
 	}
 
     Kr = dlsch->harq_processes[harq_pid]->K;
     Kr_bytes = Kr>>3;
 
-    //printf("segment Z %d kb %d k %d Kr %d BG %d\n", *pz,kb,dlsch->harq_processes[harq_pid]->K,Kr,BG);
+    //printf("segment Z %d k %d Kr %d BG %d\n", *pz,dlsch->harq_processes[harq_pid]->K,Kr,BG);
 
     //start_meas(te_stats);
     for (r=0; r<dlsch->harq_processes[harq_pid]->C; r++) {
@@ -393,6 +396,14 @@ int nr_dlsch_encoding(unsigned char *a,
   }
 
   for (r=0; r<dlsch->harq_processes[harq_pid]->C; r++) {
+
+	  	  if (dlsch->harq_processes[harq_pid]->F>0) {
+	          for (int k=(Kr-F-2*(*pz)); k<Kr-2*(*pz); k++) {
+	        	  dlsch->harq_processes[harq_pid]->d[r][k] = NR_NULL;
+	        	  //if (k<(Kr-F+8))
+	            //printf("r %d filler bits [%d] = %d \n", r,k, dlsch->harq_processes[harq_pid]->d[r][k]);
+	          }
+	  }
 #ifdef DEBUG_DLSCH_CODING
     printf("Rate Matching, Code segment %d (coded bits (G) %d,unpunctured/repeated bits per code segment %d,mod_order %d, nb_rb %d)...\n",
         r,

openair1/PHY/NR_UE_ESTIMATION/nr_dl_channel_estimation.c

@@ -32,6 +32,166 @@
 //#define DEBUG_PDCCH
 
 
+int nr_pbch_dmrs_correlation(PHY_VARS_NR_UE *ue,
+			       uint8_t eNB_offset,
+			       unsigned char Ns,
+			       unsigned char symbol,
+                               int dmrss,
+			       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;
+  int symbol_offset;
+
+
+  uint8_t nushift;
+  uint8_t ssb_index=current_ssb->i_ssb;
+  uint8_t n_hf=current_ssb->n_hf;
+  int **rxdataF=ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[Ns]].rxdataF;
+
+  nushift =  ue->frame_parms.Nid_cell%4;
+  ue->frame_parms.nushift = nushift;
+  unsigned int  ssb_offset = ue->frame_parms.first_carrier_offset + ue->frame_parms.ssb_start_subcarrier;
+  if (ssb_offset>= ue->frame_parms.ofdm_symbol_size) ssb_offset-=ue->frame_parms.ofdm_symbol_size;
+
+  AssertFatal(dmrss >= 0 && dmrss < 3,
+	      "symbol %d is illegal for PBCH DM-RS \n",
+	      dmrss);
+
+  symbol_offset = ue->frame_parms.ofdm_symbol_size*symbol;
+
+
+  k = nushift;
+
+#ifdef DEBUG_CH
+  printf("PBCH DMRS Correlation : ThreadId %d, eNB_offset %d , OFDM size %d, Ncp=%d, Ns=%d, k=%d symbol %d\n",ue->current_thread_id[Ns>>1], eNB_offset,ue->frame_parms.ofdm_symbol_size,
+         ue->frame_parms.Ncp,Ns,k, symbol);
+#endif
+
+  // generate pilot
+  nr_pbch_dmrs_rx(dmrss,ue->nr_gold_pbch[n_hf][ssb_index], &pilot[0]);
+
+  int re_offset = ssb_offset;
+  for (aarx=0; aarx<ue->frame_parms.nb_antennas_rx; aarx++) {
+
+    pil   = (int16_t *)&pilot[0];
+    rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
+
+#ifdef DEBUG_CH
+    printf("pbch ch est pilot addr %p RB_DL %d\n",&pilot[0], ue->frame_parms.N_RB_DL);
+    printf("k %d, first_carrier %d\n",k,ue->frame_parms.first_carrier_offset);
+    printf("rxF addr %p\n", rxF);
+#endif
+    //if ((ue->frame_parms.N_RB_DL&1)==0) {
+
+    // Treat first 2 pilots specially (left edge)
+    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);
+
+    current_ssb->c_re +=ch[0];
+    current_ssb->c_im +=ch[1];
+
+#ifdef DEBUG_CH
+    printf("ch 0 %d\n",((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1]));
+    printf("pilot 0 : rxF - > (%d,%d) addr %p  ch -> (%d,%d), pil -> (%d,%d) \n",rxF[0],rxF[1],&rxF[0],ch[0],ch[1],pil[0],pil[1]);
+#endif
+
+    pil+=2;
+    re_offset = (re_offset+4)&(ue->frame_parms.ofdm_symbol_size-1);
+    rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
+
+
+    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);
+
+    current_ssb->c_re +=ch[0];
+    current_ssb->c_im +=ch[1];
+
+#ifdef DEBUG_CH
+    printf("pilot 1 : rxF - > (%d,%d) ch -> (%d,%d), pil -> (%d,%d) \n",rxF[0],rxF[1],ch[0],ch[1],pil[0],pil[1]);
+#endif
+
+    pil+=2;
+    re_offset = (re_offset+4)&(ue->frame_parms.ofdm_symbol_size-1);
+    rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
+
+    current_ssb->c_re +=ch[0];
+    current_ssb->c_im +=ch[1];
+
+#ifdef DEBUG_CH
+    printf("pilot 2 : rxF - > (%d,%d) ch -> (%d,%d), pil -> (%d,%d) \n",rxF[0],rxF[1],ch[0],ch[1],pil[0],pil[1]);
+#endif
+
+    pil+=2;
+    re_offset = (re_offset+4)&(ue->frame_parms.ofdm_symbol_size-1);
+    rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
+
+    for (pilot_cnt=3; pilot_cnt<(3*20); pilot_cnt+=3) {
+
+      //	if (pilot_cnt == 30)
+      //	  rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k)];
+
+      // in 2nd symbol, skip middle  REs (48 with DMRS,  144 for SSS, and another 48 with DMRS) 
+      if (dmrss == 1 && pilot_cnt == 12) {
+	pilot_cnt=48;
+	re_offset = (re_offset+144)&(ue->frame_parms.ofdm_symbol_size-1);
+	rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
+      }
+      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);
+      
+      current_ssb->c_re +=ch[0];
+      current_ssb->c_im +=ch[1];
+
+#ifdef DEBUG_CH
+      printf("pilot %d : rxF - > (%d,%d) ch -> (%d,%d), pil -> (%d,%d) \n",pilot_cnt,rxF[0],rxF[1],ch[0],ch[1],pil[0],pil[1]);
+#endif
+
+      pil+=2;
+      re_offset = (re_offset+4)&(ue->frame_parms.ofdm_symbol_size-1);
+      rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
+        
+  
+      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);
+
+      current_ssb->c_re +=ch[0];
+      current_ssb->c_im +=ch[1];
+
+#ifdef DEBUG_CH
+      printf("pilot %d : rxF - > (%d,%d) ch -> (%d,%d), pil -> (%d,%d) \n",pilot_cnt+1,rxF[0],rxF[1],ch[0],ch[1],pil[0],pil[1]);
+#endif
+      pil+=2;
+      re_offset = (re_offset+4)&(ue->frame_parms.ofdm_symbol_size-1);
+      rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
+        
+
+      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);
+
+      current_ssb->c_re +=ch[0];
+      current_ssb->c_im +=ch[1];
+
+#ifdef DEBUG_CH
+      printf("pilot %d : rxF - > (%d,%d) ch -> (%d,%d), pil -> (%d,%d) \n",pilot_cnt+2,rxF[0],rxF[1],ch[0],ch[1],pil[0],pil[1]);
+#endif
+
+      pil+=2;
+      re_offset = (re_offset+4)&(ue->frame_parms.ofdm_symbol_size-1);
+      rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
+
+    }
+
+
+    //}
+
+  }
+  return(0);
+}
+
 
 int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
 			       uint8_t eNB_offset,

openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h

@@ -50,6 +50,13 @@ int nr_pdcch_channel_estimation(PHY_VARS_NR_UE *ue,
 				unsigned short coreset_start_subcarrier,
 				unsigned short nb_rb_coreset);
 
+int nr_pbch_dmrs_correlation(PHY_VARS_NR_UE *ue,
+                             uint8_t eNB_offset,
+                             unsigned char Ns,
+                             unsigned char symbol,
+			     int dmrss,
+			     NR_UE_SSB *current_ssb);
+
 int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
                                uint8_t eNB_offset,
                                unsigned char Ns,

openair1/PHY/NR_UE_TRANSPORT/dci_nr.c

@@ -1418,27 +1418,25 @@ void nr_dci_decoding_procedure0(int s,
         *format_found=_format_2_3_found;
       }
 
-      #ifdef NR_PDCCH_DCI_DEBUG
+
+#ifdef NR_PDCCH_DCI_DEBUG
       printf ("\t\t<-NR_PDCCH_DCI_DEBUG (nr_dci_decoding_procedure0)-> format_found=%d\n",*format_found);
       printf ("\t\t<-NR_PDCCH_DCI_DEBUG (nr_dci_decoding_procedure0)-> crc_scrambled=%d\n",*crc_scrambled);
-      #endif
+#endif
 
       if (*format_found!=255) {
         dci_alloc[*dci_cnt].dci_length = sizeof_bits;
         dci_alloc[*dci_cnt].rnti = crc;
         dci_alloc[*dci_cnt].L = L;
         dci_alloc[*dci_cnt].firstCCE = CCEind;
-        dci_alloc[*dci_cnt].dci_pdu[0] = dci_estimation[0];
-        dci_alloc[*dci_cnt].dci_pdu[1] = dci_estimation[1];
-        dci_alloc[*dci_cnt].dci_pdu[2] = dci_estimation[2];
-        dci_alloc[*dci_cnt].dci_pdu[3] = dci_estimation[3];
-        #ifdef NR_PDCCH_DCI_DEBUG
+        memcpy(&dci_alloc[*dci_cnt].dci_pdu[0],dci_estimation,8);
+
+#ifdef NR_PDCCH_DCI_DEBUG
         printf ("\t\t<-NR_PDCCH_DCI_DEBUG (nr_dci_decoding_procedure0)-> rnti matches -> DCI FOUND !!! crc =>0x%x, sizeof_bits %d, sizeof_bytes %d \n",
                 dci_alloc[*dci_cnt].rnti, dci_alloc[*dci_cnt].dci_length, sizeof_bytes);
         printf ("\t\t<-NR_PDCCH_DCI_DEBUG (nr_dci_decoding_procedure0)-> dci_cnt %d (format_css %d crc_scrambled %d) L %d, firstCCE %d pdu[0] 0x%lx pdu[1] 0x%lx \n",
                 *dci_cnt, format_css,*crc_scrambled,dci_alloc[*dci_cnt].L, dci_alloc[*dci_cnt].firstCCE,dci_alloc[*dci_cnt].dci_pdu[0],dci_alloc[*dci_cnt].dci_pdu[1]);
-
-        #endif
+#endif
         if ((format_css == cformat0_0_and_1_0) || (format_uss == uformat0_0_and_1_0)) {
           if ((*crc_scrambled == _p_rnti) || (*crc_scrambled == _si_rnti) || (*crc_scrambled == _ra_rnti)) {
             dci_alloc[*dci_cnt].format = format1_0;

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c

@@ -218,8 +218,7 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
   uint32_t A,E;
   uint32_t G;
   uint32_t ret,offset;
-  int32_t no_iteration_ldpc;
-  //short dummy_w[MAX_NUM_DLSCH_SEGMENTS][3*(8448+64)];
+  int32_t no_iteration_ldpc, length_dec;
   uint32_t r,r_offset=0,Kr=8424,Kr_bytes,K_bytes_F,err_flag=0;
   uint8_t crc_type;
   int8_t llrProcBuf[OAI_LDPC_MAX_NUM_LLR] __attribute__ ((aligned(32)));
@@ -233,17 +232,15 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
   int8_t l [68*384];
   //__m128i l;
   int16_t inv_d [68*384];
-//  int16_t *p_invd =&inv_d;
-  uint8_t kb, kc;
+  uint8_t kc;
   uint8_t Ilbrm = 0;
   uint32_t Tbslbrm = 950984;
   uint16_t nb_rb = 30; //to update
-  //uint16_t nb_symb_sch = 12;
   uint8_t nb_re_dmrs = 6;
   uint16_t length_dmrs = 1;
+  double Coderate = 0.0;
 
   uint32_t i,j;
-//  uint32_t k;
 
   __m128i *pv = (__m128i*)&z;
   __m128i *pl = (__m128i*)&l;
@@ -322,21 +319,41 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
     	printf("K %d C %d Z %d nl %d \n", harq_process->K, harq_process->C, p_decParams->Z, harq_process->Nl);
 #endif
   }
-
-      kb = harq_process->K/harq_process->Z;
-  	  if ( kb==22){
-  		  p_decParams->BG = 1;
-  		  p_decParams->R = 13;
-  		  kc = 68;
+      Coderate = (float) A /(float) G;
+      if ((A <=292) || ((A<=3824) && (Coderate <= 0.6667)) || Coderate <= 0.25){
+  		  p_decParams->BG = 2;
+  		  if (Coderate < 0.3333){
+  			  p_decParams->R = 15;
+  			  kc = 52;
+  		  }
+  		  else if (Coderate <0.6667){
+  			  p_decParams->R = 13;
+  			  kc = 32;
+  		  }
+  		  else {
+  		  	  p_decParams->R = 23;
+  		  	  kc = 17;
+  		  }
   	  }
   	  else{
-  		  p_decParams->BG = 2;
-  		  p_decParams->R = 13;
-  		  kc = 52;
-  	  	  }
+  		  p_decParams->BG = 1;
+  		  if (Coderate < 0.6667){
+  			  p_decParams->R = 13;
+  			  kc = 68;
+  		  }
+  		  else if (Coderate <0.8889){
+  			  p_decParams->R = 23;
+  			  kc = 35;
+  		  }
+  		  else {
+  			  p_decParams->R = 89;
+  			  kc = 27;
+  		  }
+  	  }
+
+  	  //printf("coderate %f kc %d \n", Coderate, kc);
 
       p_decParams->numMaxIter = dlsch->max_ldpc_iterations;
-      Kr = p_decParams->Z*kb;
       p_decParams->outMode= 0;
 
 
@@ -453,54 +470,38 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
     memset(harq_process->c[r],0,Kr_bytes);
 
     //    printf("done\n");
-    if (harq_process->C == 1)
+    if (harq_process->C == 1){
       crc_type = CRC24_A;
-    else
+      length_dec = harq_process->B;
+    }
+    else{
       crc_type = CRC24_B;
+      length_dec = (harq_process->B+24*harq_process->C)/harq_process->C;
+    }
 
     if (err_flag == 0) {
-/*
-        LOG_I(PHY, "turbo algo Kr=%d cb_cnt=%d C=%d nbRB=%d crc_type %d TBSInput=%d TBSHarq=%d TBSplus24=%d mcs=%d Qm=%d RIV=%d round=%d maxIter %d\n",
-                            Kr,r,harq_process->C,harq_process->nb_rb,crc_type,A,harq_process->TBS,
-                            harq_process->B,harq_process->mcs,harq_process->Qm,harq_process->rvidx,harq_process->round,dlsch->max_ldpc_iterations);
-*/
 
 #if UE_TIMING_TRACE
         start_meas(dlsch_turbo_decoding_stats);
 #endif
 
-      //LOG_E(PHY,"AbsSubframe %d.%d Start turbo segment %d/%d A %d ",frame%1024,nr_tti_rx,r,harq_process->C-1, A);
+      //LOG_E(PHY,"AbsSubframe %d.%d Start LDPC segment %d/%d A %d ",frame%1024,nr_tti_rx,r,harq_process->C-1, A);
 
       //printf("harq process dr iteration %d\n", p_decParams->numMaxIter);
 
-      for (int cnt =0; cnt < (kc-2)*p_decParams->Z; cnt++){
-            inv_d[cnt] = (1)*harq_process->d[r][cnt];
-            }
 
-      /*for (int cnt =0; cnt < 16; cnt++){
-      printf("dr %d inv_d %d \n", harq_process->d[r][cnt], inv_d[cnt]);
-      }
-
-      printf(" \n");
-
-      printf("end dr \n");
-      for (int cnt =(50*p_decParams->Z-16) ; cnt < 50*p_decParams->Z; cnt++){
-            printf("%d ", harq_process->d[r][cnt]);
-            }
-      printf(" \n");*/
-
-		memset(pv,0,2*harq_process->Z*sizeof(int16_t));
+        memset(pv,0,2*harq_process->Z*sizeof(int16_t));
         //memset(pl,0,2*p_decParams->Z*sizeof(int8_t));
     	memset((pv+K_bytes_F),127,harq_process->F*sizeof(int16_t));
 
-      	for (i=((2*p_decParams->Z)>>3), j = 0; i < K_bytes_F+((2*p_decParams->Z)>>3); i++, j++)
+      	for (i=((2*p_decParams->Z)>>3), j = 0; i < K_bytes_F; i++, j++)
       	{
-      		pv[i]= _mm_loadu_si128((__m128i*)(&inv_d[8*j]));
+      		pv[i]= _mm_loadu_si128((__m128i*)(&harq_process->d[r][8*j]));
       	}
 
-		for (i=Kr_bytes+((2*p_decParams->Z)>>3),j=Kr_bytes; i < ((kc*p_decParams->Z)>>3); i++, j++)
+		for (i=Kr_bytes,j=K_bytes_F-((2*p_decParams->Z)>>3); i < ((kc*p_decParams->Z)>>3); i++, j++)
 		      	{
-		      		pv[i]= _mm_loadu_si128((__m128i*)(&inv_d[8*j]));
+		      		pv[i]= _mm_loadu_si128((__m128i*)(&harq_process->d[r][8*j]));
 		      	}
       	
 		for (i=0, j=0; j < ((kc*p_decParams->Z)>>4);  i+=2, j++)
@@ -517,8 +518,8 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
                            p_procTime);
 
 		// Fixme: correct type is unsigned, but nrLDPC_decoder and all called behind use signed int
-		if (check_crc((uint8_t*)llrProcBuf,harq_process->B,harq_process->F,crc_type)) {
-		  printf("CRC OK\n");
+		if (check_crc((uint8_t*)llrProcBuf,length_dec,harq_process->F,crc_type)) {
+		  printf("Segment %d CRC OK\n",r);
 		  ret = 2;
 		}
 		else {

openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync.c

@@ -54,11 +54,62 @@ int cnt=0;
 #define DEBUG_INITIAL_SYNCH
 
 
+// create a new node of SSB structure
+NR_UE_SSB* create_ssb_node(uint8_t  i, uint8_t  h) {
+
+  NR_UE_SSB *new_node = (NR_UE_SSB*)malloc(sizeof(NR_UE_SSB));
+  new_node->i_ssb = i;
+  new_node->n_hf = h;
+  new_node->c_re = 0;
+  new_node->c_im = 0;
+  new_node->metric = 0;
+  new_node->next_ssb = NULL;
+
+  return new_node;
+}
+
+
+// insertion of the structure in the ordered list (highest metric first)
+NR_UE_SSB* insert_into_list(NR_UE_SSB *head, NR_UE_SSB *node) {
+
+  if (node->metric > head->metric) {
+    node->next_ssb = head;
+    head = node;
+    return head;
+  }
+
+  NR_UE_SSB *current = head;
+  while (current->next_ssb !=NULL) {
+    NR_UE_SSB *temp=current->next_ssb;
+    if(node->metric > temp->metric) {
+      node->next_ssb = temp;
+      current->next_ssb = node;
+      return head;
+    }
+    else
+      current = temp;
+  }
+  current->next_ssb = node;
+
+  return head;
+}
+
+
+void free_list(NR_UE_SSB *node) {
+  if (node->next_ssb != NULL)
+    free_list(node->next_ssb);
+  free(node);
+}
+
+
 int nr_pbch_detection(PHY_VARS_NR_UE *ue, int pbch_initial_symbol, runmode_t mode)
 {
   NR_DL_FRAME_PARMS *frame_parms=&ue->frame_parms;
   int ret =-1;
 
+  NR_UE_SSB *best_ssb = NULL;
+  NR_UE_SSB *current_ssb;
+
 #ifdef DEBUG_INITIAL_SYNCH
   LOG_I(PHY,"[UE%d] Initial sync: starting PBCH detection (rx_offset %d)\n",ue->Mod_id,
         ue->rx_offset);
@@ -70,30 +121,59 @@ int nr_pbch_detection(PHY_VARS_NR_UE *ue, int pbch_initial_symbol, runmode_t mod
   // loops over possible pbch dmrs cases to retrive best estimated i_ssb (and n_hf for Lmax=4) for multiple ssb detection
   for (int hf = 0; hf < N_hf; hf++) {
     for (int l = 0; l < N_L ; l++) {
-      if (ret !=0) {
+
+      // initialization of structure
+      current_ssb = create_ssb_node(l,hf);
 
 #if UE_TIMING_TRACE
-        start_meas(&ue->dlsch_channel_estimation_stats);
+      start_meas(&ue->dlsch_channel_estimation_stats);
 #endif
-        for(int i=pbch_initial_symbol; i<pbch_initial_symbol+3;i++)
-          nr_pbch_channel_estimation(ue,0,0,i,i-pbch_initial_symbol,l,hf);
+      // computing correlation between received DMRS symbols and transmitted sequence for current i_ssb and n_hf
+      for(int i=pbch_initial_symbol; i<pbch_initial_symbol+3;i++)
+          nr_pbch_dmrs_correlation(ue,0,0,i,i-pbch_initial_symbol,current_ssb);
 #if UE_TIMING_TRACE
-        stop_meas(&ue->dlsch_channel_estimation_stats);
+      stop_meas(&ue->dlsch_channel_estimation_stats);
 #endif
+      
+      current_ssb->metric = current_ssb->c_re*current_ssb->c_re + current_ssb->c_im+current_ssb->c_re;
+      
+      // generate a list of SSB structures
+      if (best_ssb == NULL)
+        best_ssb = current_ssb;
+      else
+        best_ssb = insert_into_list(best_ssb,current_ssb);
 
-        ret = nr_rx_pbch(ue,
-	                 &ue->proc.proc_rxtx[0],
-		         ue->pbch_vars[0],
-		         frame_parms,
-		         0,
-			 l,
-                         SISO,
-		         ue->high_speed_flag);
-
-      }
     }
   }
 
+  NR_UE_SSB *temp_ptr=best_ssb;
+  while (ret!=0 && temp_ptr != NULL) {
+
+#if UE_TIMING_TRACE
+    start_meas(&ue->dlsch_channel_estimation_stats);
+#endif
+  // computing channel estimation for selected best ssb
+    for(int i=pbch_initial_symbol; i<pbch_initial_symbol+3;i++)
+      nr_pbch_channel_estimation(ue,0,0,i,i-pbch_initial_symbol,temp_ptr->i_ssb,temp_ptr->n_hf);
+#if UE_TIMING_TRACE
+    stop_meas(&ue->dlsch_channel_estimation_stats);
+#endif
+
+    ret = nr_rx_pbch(ue,
+	             0,
+		     ue->pbch_vars[0],
+		     frame_parms,
+		     0,
+		     temp_ptr->i_ssb,
+                     SISO,
+                     ue->high_speed_flag);
+
+    temp_ptr=temp_ptr->next_ssb;
+  }
+
+  free_list(best_ssb);
+
+  
   if (ret==0) {
     
     frame_parms->nb_antenna_ports_eNB = 1; //pbch_tx_ant;

openair1/PHY/NR_UE_TRANSPORT/nr_pbch.c

@@ -410,7 +410,7 @@ unsigned char sign(int8_t x) {
 uint8_t pbch_deinterleaving_pattern[32] = {28,0,31,30,7,29,25,27,5,8,24,9,10,11,12,13,1,4,3,14,15,16,17,2,26,18,19,20,21,22,6,23};
 
 int nr_rx_pbch( PHY_VARS_NR_UE *ue,
-                UE_nr_rxtx_proc_t *proc,
+                int subframe_rx,
                 NR_UE_PBCH *nr_ue_pbch_vars,
                 NR_DL_FRAME_PARMS *frame_parms,
                 uint8_t eNB_id,
@@ -436,7 +436,7 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
   //time_stats_t path_metric,sorting,update_LLR;
   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);
-  int subframe_rx = proc->subframe_rx;
+
   pbch_e_rx = &nr_ue_pbch_vars->llr[0];
   // clear LLR buffer
   memset(nr_ue_pbch_vars->llr,0,NR_POLAR_PBCH_E);

openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h

@@ -1118,7 +1118,7 @@ int rx_sss(PHY_VARS_NR_UE *phy_vars_ue,int32_t *tot_metric,uint8_t *flip_max,uin
   \returns number of tx antennas or -1 if error
 */
 int nr_rx_pbch( PHY_VARS_NR_UE *ue,
-		     UE_nr_rxtx_proc_t *proc,
+		     int subframe_rx,
 		     NR_UE_PBCH *nr_ue_pbch_vars,
 		     NR_DL_FRAME_PARMS *frame_parms,
 		     uint8_t eNB_id,
@@ -1680,7 +1680,7 @@ int nr_generate_ue_ul_dlsch_params_from_dci(PHY_VARS_NR_UE *ue,
         uint8_t eNB_id,
         int frame,
         uint8_t nr_tti_rx,
-        uint32_t dci_pdu[4],
+        uint64_t dci_pdu[2],
         uint16_t rnti,
         uint8_t dci_length,
         NR_DCI_format_t dci_format,

openair1/PHY/defs_nr_UE.h

@@ -950,6 +950,16 @@ typedef struct {
   int16_t *prach;
 } NR_UE_PRACH;
 
+// structure used for multiple SSB detection
+typedef struct NR_UE_SSB {
+  uint8_t i_ssb;   // i_ssb between 0 and 7 (it corresponds to ssb_index only for Lmax=4,8)
+  uint8_t n_hf;    // n_hf = 0,1 for Lmax =4 or n_hf = 0 for Lmax =8,64
+  uint32_t metric; // metric to order SSB hypothesis
+  uint32_t c_re;
+  uint32_t c_im;
+  struct NR_UE_SSB *next_ssb;
+} NR_UE_SSB;
+
 /*typedef enum {
   /// do not detect any DCIs in the current subframe
   NO_DCI = 0x0,
@@ -1081,7 +1091,7 @@ typedef struct {
   uint32_t nr_gold_pbch[2][64][NR_PBCH_DMRS_LENGTH_DWORD];
 
   /// PDSCH DMRS
-  uint32_t nr_gold_pdsch[2][20][2][21];
+  uint32_t nr_gold_pdsch[2][20][2][52];
 
   /// PDCCH DMRS
   uint32_t nr_gold_pdcch[7][20][3][52];

openair1/PHY/defs_nr_common.h

@@ -321,4 +321,23 @@ typedef struct NR_DL_FRAME_PARMS {
 
 } NR_DL_FRAME_PARMS;
 
+#define KHz (1000UL)
+#define MHz (1000*KHz)
+
+typedef struct nr_bandentry_s {
+  int16_t band;
+  uint64_t ul_min;
+  uint64_t ul_max;
+  uint64_t dl_min;
+  uint64_t dl_max;
+  uint64_t N_OFFs_DL;
+  uint64_t step_size;
+} nr_bandentry_t;
+
+typedef struct nr_band_info_s {
+  int nbands;
+  nr_bandentry_t band_info[100];
+} nr_band_info_t;
+
+
 #endif

openair1/SCHED_NR_UE/phy_procedures_nr_ue.c

@@ -123,7 +123,7 @@ int nr_generate_ue_ul_dlsch_params_from_dci(PHY_VARS_NR_UE *ue,
 					    uint8_t eNB_id,
 					    int frame,
 					    uint8_t nr_tti_rx,
-					    uint32_t dci_pdu[4],
+					    uint64_t dci_pdu[2],
 					    uint16_t rnti,
 					    uint8_t dci_length,
 					    NR_DCI_format_t dci_format,
@@ -2760,37 +2760,6 @@ void nr_ue_measurement_procedures(
 
   }
 #endif
-  // accumulate and filter timing offset estimation every nr_tti_rx (instead of every frame)
-  if (( slot == 2) && (l==(1-frame_parms->Ncp))) {
-
-    // AGC
-/*
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GAIN_CONTROL, VCD_FUNCTION_IN);
-
-#ifndef OAI_USRP
-#ifndef OAI_BLADERF
-#ifndef OAI_LMSSDR
-#ifndef OAI_ADRV9371_ZC706
-    phy_adjust_gain (ue,dB_fixed(ue->measurements.rssi),0);
-#endif
-#endif
-#endif
-#endif
-
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GAIN_CONTROL, VCD_FUNCTION_OUT);
-*/
-    eNB_id = 0;
-
-      LOG_D(PHY,"start adjust sync l = %d slot = %d no timing %d\n",l, slot, ue->no_timing_correction);
-      if (ue->no_timing_correction==0)
-	nr_adjust_synch_ue(&ue->frame_parms,
-			   ue,
-			   eNB_id,
-			   nr_tti_rx,
-			   0,
-			   16384);
-    
-  }
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_MEASUREMENT_PROCEDURES, VCD_FUNCTION_OUT);
 }
@@ -2969,7 +2938,7 @@ void nr_ue_pbch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_PBCH_PROCEDURES, VCD_FUNCTION_IN);
 
   //LOG_I(PHY,"[UE  %d] Frame %d, Trying PBCH %d (NidCell %d, eNB_id %d)\n",ue->Mod_id,frame_rx,pbch_phase,ue->frame_parms.Nid_cell,eNB_id);
-  ret = nr_rx_pbch(ue, proc,
+  ret = nr_rx_pbch(ue, proc->subframe_rx,
 		   ue->pbch_vars[eNB_id],
 		   &ue->frame_parms,
 		   eNB_id,
@@ -3088,7 +3057,7 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
   uint16_t p_rnti=P_RNTI;
   uint16_t si_rnti=SI_RNTI;
   uint16_t ra_rnti=99;
-  uint16_t sp_csi_rnti,sfi_rnti,int_rnti,tpc_pusch_rnti,tpc_pucch_rnti,tpc_srs_rnti; //FIXME
+  uint16_t sp_csi_rnti=0,sfi_rnti=0,int_rnti=0,tpc_pusch_rnti=0,tpc_pucch_rnti=0,tpc_srs_rnti=0; //FIXME
   uint16_t crc_scrambled_values[TOTAL_NBR_SCRAMBLED_VALUES] =
     {c_rnti,cs_rnti,new_rnti,tc_rnti,p_rnti,si_rnti,ra_rnti,sp_csi_rnti,sfi_rnti,int_rnti,tpc_pusch_rnti,tpc_pucch_rnti,tpc_srs_rnti};
   #ifdef NR_PDCCH_SCHED_DEBUG
@@ -3367,7 +3336,7 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
 
 
   } // end for loop nb_searchspace_active
-  return(0);
+  return(dci_cnt);
 }
 #endif // NR_PDCCH_SCHED
 
@@ -4974,6 +4943,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
   uint8_t nb_symb_pdcch = pdcch_vars->coreset[0].duration;
   uint8_t ssb_periodicity = ue->ssb_periodicity; // initialized to 20ms in nr_init_ue and never changed for now
   uint8_t ssb_frame_periodicity;  
+  uint8_t dci_cnt = 0;
   
   LOG_D(PHY," ****** start RX-Chain for Frame.Slot %d.%d ******  \n", frame_rx%1024, nr_tti_rx);
 
@@ -4983,7 +4953,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
 #ifdef NR_PDCCH_SCHED
   nr_gold_pdcch(ue,0, 2);
   
-  //if (nr_tti_rx==1){
+
   LOG_D(PHY," ------ --> PDCCH ChannelComp/LLR Frame.slot %d.%d ------  \n", frame_rx%1024, nr_tti_rx);
   for (uint16_t l=0; l<nb_symb_pdcch; l++) {
     
@@ -5003,15 +4973,29 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
 #endif
     
     //printf("phy procedure pdcch start measurement l =%d\n",l);
-    nr_ue_measurement_procedures(l,ue,proc,eNB_id,(nr_tti_rx),mode);
+    //nr_ue_measurement_procedures(l,ue,proc,eNB_id,(nr_tti_rx),mode);
       
   }
 
-  if (nr_ue_pdcch_procedures(eNB_id,ue,proc) == -1) {
-    LOG_E(PHY,"[UE  %d] Frame %d, nr_tti_rx %d: Error in pdcch procedures\n",ue->Mod_id,frame_rx,nr_tti_rx);
-    return(-1);
+  dci_cnt = nr_ue_pdcch_procedures(eNB_id,ue,proc);
+
+  if (dci_cnt > 0) {
+
+    LOG_I(PHY,"[UE  %d] Frame %d, nr_tti_rx %d: found %d DCIs\n",ue->Mod_id,frame_rx,nr_tti_rx,dci_cnt);
+    
+    if (0/*ue->no_timing_correction==0*/) {
+      LOG_I(PHY,"start adjust sync slot = %d no timing %d\n", nr_tti_rx, ue->no_timing_correction);
+      nr_adjust_synch_ue(&ue->frame_parms,
+			 ue,
+			 eNB_id,
+			 nr_tti_rx,
+			 0,
+			 16384);
+    }
+  }
+  else {
+    LOG_D(PHY,"[UE  %d] Frame %d, nr_tti_rx %d: No DCIs found\n",ue->Mod_id,frame_rx,nr_tti_rx);
   }
-  //}
 #endif //NR_PDCCH_SCHED
 
   

openair1/SIMULATION/NR_PHY/dlsim.c

@@ -154,7 +154,7 @@ int main(int argc, char **argv)
   int pbch_tx_ant;
   int N_RB_DL=273,mu=1;
 
-  uint64_t ssb_pattern = 0;
+  uint64_t ssb_pattern = 0x01;
 
   unsigned char frame_type = 0;
   unsigned char pbch_phase = 0;

openair1/SIMULATION/NR_PHY/pbchsim.c

@@ -618,9 +618,18 @@ int main(int argc, char **argv)
 		      0,
 		      0,
 		      NR_PBCH_EST);
+
+          nr_pbch_channel_estimation(UE,0,0,i,i-(UE->symbol_offset+1),ssb_index%8,n_hf);
         }
 
-	ret = nr_pbch_detection(UE,UE->symbol_offset+1,0);
+        ret = nr_rx_pbch(UE,
+	                 0,
+		         UE->pbch_vars[0],
+		         frame_parms,
+		         0,
+		         ssb_index%8,
+                         SISO,
+                         UE->high_speed_flag);
 
 	if (ret==0) {
 	  //UE->rx_ind.rx_indication_body->mib_pdu.ssb_index;  //not yet detected automatically

openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c

@@ -1754,7 +1754,7 @@ printf("\n>>> nr_ue_process_dci at MAC layer with dci_format=%d\n",dci_format);
                     dci->time_dom_resource_assignment,
                     dlsch_config_pdu_1_0->number_symbols,
                     dlsch_config_pdu_1_0->start_symbol);
-            printf(">>> (nr_ue_procedures.c) vrb_to_prb_mapping=%d \n>>> mcs=%d\n>>> ndi=%d\n>>> rv=%d\n>>> harq_process_nbr=%d\n>>> dai=%d\n>>> scaling_factor_S=%d\n>>> tpc_pucch=%d\n>>> pucch_res_ind=%d\n>>> pdsch_to_harq_feedback_time_ind=%d\n",
+            printf(">>> (nr_ue_procedures.c) vrb_to_prb_mapping=%d \n>>> mcs=%d\n>>> ndi=%d\n>>> rv=%d\n>>> harq_process_nbr=%d\n>>> dai=%d\n>>> scaling_factor_S=%f\n>>> tpc_pucch=%d\n>>> pucch_res_ind=%d\n>>> pdsch_to_harq_feedback_time_ind=%d\n",
                   dlsch_config_pdu_1_0->vrb_to_prb_mapping,
                   dlsch_config_pdu_1_0->mcs,
                   dlsch_config_pdu_1_0->ndi,

openair2/LAYER2/NR_MAC_gNB/config.c

@@ -49,110 +49,6 @@ extern RAN_CONTEXT_t RC;
 extern void mac_top_init_gNB(void);
 extern uint8_t nfapi_mode;
 
-int32_t **rxdata;
-int32_t **txdata;
-
-typedef struct nr_bandentry_s {
-  int16_t band;
-  uint64_t ul_min;
-  uint64_t ul_max;
-  uint64_t dl_min;
-  uint64_t dl_max;
-  uint64_t N_OFFs_DL;
-  uint64_t step_size;
-} nr_bandentry_t;
-
-typedef struct band_info_s {
-  int nbands;
-  nr_bandentry_t band_info[100];
-} nr_band_info_t;
-
-static const nr_bandentry_t nr_bandtable[] = {
-  {1,  1920000, 1980000, 2110000, 2170000, 20, 422000},
-  {2,  1850000, 1910000, 1930000, 1990000, 20, 386000},
-  {3,  1710000, 1785000, 1805000, 1880000, 20, 361000},
-  {5,   824000,  849000,  869000,  894000, 20, 173800},
-  {7,  2500000, 2570000, 2620000, 2690000, 20, 524000},
-  {8,   880000,  915000,  925000,  960000, 20, 185000},
-  {12,  698000,  716000,  728000,  746000, 20, 145800},
-  {20,  832000,  862000,  791000,  821000, 20, 158200},
-  {25, 1850000, 1915000, 1930000, 1995000, 20, 386000},
-  {28,  703000,  758000,  758000,  813000, 20, 151600},
-  {34, 2010000, 2025000, 2010000, 2025000, 20, 402000},
-  {38, 2570000, 2620000, 2570000, 2630000, 20, 514000},
-  {39, 1880000, 1920000, 1880000, 1920000, 20, 376000},
-  {40, 2300000, 2400000, 2300000, 2400000, 20, 460000},
-  {41, 2496000, 2690000, 2496000, 2690000,  3, 499200},
-  {50, 1432000, 1517000, 1432000, 1517000, 20, 286400},
-  {51, 1427000, 1432000, 1427000, 1432000, 20, 285400},
-  {66, 1710000, 1780000, 2110000, 2200000, 20, 422000},
-  {70, 1695000, 1710000, 1995000, 2020000, 20, 399000},
-  {71,  663000,  698000,  617000,  652000, 20, 123400},
-  {74, 1427000, 1470000, 1475000, 1518000, 20, 295000},
-  {75,     000,     000, 1432000, 1517000, 20, 286400},
-  {76,     000,     000, 1427000, 1432000, 20, 285400},
-  {77, 3300000, 4200000, 3300000, 4200000,  1, 620000},
-  {78, 3300000, 3800000, 3300000, 3800000,  1, 620000},
-  {79, 4400000, 5000000, 4400000, 5000000,  2, 693334},
-  {80, 1710000, 1785000,     000,     000, 20, 342000},
-  {81,  860000,  915000,     000,     000, 20, 176000},
-  {82,  832000,  862000,     000,     000, 20, 166400},
-  {83,  703000,  748000,     000,     000, 20, 140600},
-  {84, 1920000, 1980000,     000,     000, 20, 384000},
-  {86, 1710000, 1785000,     000,     000, 20, 342000}
-};
-
-
-uint32_t to_nrarfcn(int nr_bandP, uint64_t dl_CarrierFreq, uint32_t bw)
-{
-
-  uint64_t dl_CarrierFreq_by_1k = dl_CarrierFreq / 1000;
-  int bw_kHz = bw / 1000;
-
-  int i;
-
-  LOG_I(MAC,"Searching for nr band %d DL Carrier frequency %llu bw %u\n",nr_bandP,(long long unsigned int)dl_CarrierFreq,bw);
-  AssertFatal(nr_bandP < 86, "nr_band %d > 86\n", nr_bandP);
-  for (i = 0; i < 30 && nr_bandtable[i].band != nr_bandP; i++);
-
-  AssertFatal(dl_CarrierFreq_by_1k >= nr_bandtable[i].dl_min,
-        "Band %d, bw %u : DL carrier frequency %llu kHz < %llu\n",
-	      nr_bandP, bw, (long long unsigned int)dl_CarrierFreq_by_1k,
-	      (long long unsigned int)nr_bandtable[i].dl_min);
-  AssertFatal(dl_CarrierFreq_by_1k <=
-        (nr_bandtable[i].dl_max - bw_kHz),
-        "Band %d, dl_CarrierFreq %llu bw %u: DL carrier frequency %llu kHz > %llu\n",
-	      nr_bandP, (long long unsigned int)dl_CarrierFreq,bw, (long long unsigned int)dl_CarrierFreq_by_1k,
-	      (long long unsigned int)(nr_bandtable[i].dl_max - bw_kHz));
- 
-  int deltaFglobal;
-
-  if (dl_CarrierFreq < 3e9) deltaFglobal = 5;
-  else                      deltaFglobal = 15;
-
-  // This is equation before Table 5.4.2.1-1 in 38101-1-f30
-  // F_REF=F_REF_Offs + deltaF_Global(N_REF-NREF_REF_Offs)
-  return (((dl_CarrierFreq_by_1k - nr_bandtable[i].dl_min)/deltaFglobal) +
-	  nr_bandtable[i].N_OFFs_DL);
-}
-
-
-uint64_t from_nrarfcn(int nr_bandP, uint32_t dl_nrarfcn)
-{
-
-  int i;
-  int deltaFglobal;
-
-  if (nr_bandP < 77 || nr_bandP > 79) deltaFglobal = 5;
-  else                                deltaFglobal = 15;
-  
-  AssertFatal(nr_bandP < 87, "nr_band %d > 86\n", nr_bandP);
-  for (i = 0; i < 31 && nr_bandtable[i].band != nr_bandP; i++);
-  AssertFatal(dl_nrarfcn>=nr_bandtable[i].N_OFFs_DL,"dl_nrarfcn %u < N_OFFs_DL %llu\n",dl_nrarfcn, (long long unsigned int)nr_bandtable[i].N_OFFs_DL);
- 
-  return 1000*(nr_bandtable[i].dl_min + (dl_nrarfcn - nr_bandtable[i].N_OFFs_DL) * deltaFglobal);
-	  
-}
 
 void config_nr_mib(int Mod_idP, 
                 int CC_idP,

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler.c

@@ -396,6 +396,7 @@ void gNB_dlsch_ulsch_scheduler(module_id_t module_idP,
             NR_gNB_DLSCH_t *dlsch = RC.gNB[module_idP][CC_id]->dlsch[ii][0];
             if((dlsch != NULL) && (dlsch->rnti == rnti)){
               LOG_I(MAC, "clean_eNb_dlsch UE %x \n", rnti);
+	      LOG_E(PHY,"Calling with wrong paramter type\n");
               clean_eNb_dlsch(dlsch);
             }
           }

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c

@@ -462,6 +462,3 @@ int get_symbolsperslot(nfapi_nr_config_request_t *cfg) {
 
 }
 
-int nr_schedule_dci() {
-  
-}

openair2/LAYER2/NR_MAC_gNB/mac_proto.h

@@ -103,4 +103,10 @@ int to_absslot(nfapi_nr_config_request_t *cfg,int frame,int slot);
 
 int get_symbolsperslot(nfapi_nr_config_request_t *cfg);
 
+void get_band(uint32_t downlink_frequency,   uint8_t *current_band,   int32_t *current_offset, lte_frame_type_t *current_type);
+
+uint64_t from_nrarfcn(int nr_bandP, uint32_t dl_nrarfcn);
+
+uint32_t to_nrarfcn(int nr_bandP, uint64_t dl_CarrierFreq, uint32_t bw);
+
 #endif /*__LAYER2_NR_MAC_PROTO_H__*/

openair2/LAYER2/NR_MAC_gNB/nr_mac_common.c

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file nr_mac_common.c
+ * \brief Common MAC functions for NR UE and gNB
+ * \author  Florian Kaltenberger and Raymond Knopp
+ * \date 2019
+ * \version 0.1
+ * \company Eurecom, NTUST
+ * \email: florian.kalteberger@eurecom.fr, raymond.knopp@eurecom.fr
+ * @ingroup _mac
+
+ */
+
+#include "LAYER2/NR_MAC_gNB/mac_proto.h"
+
+nr_bandentry_t nr_bandtable[] = {
+  {1,  1920000, 1980000, 2110000, 2170000, 20, 422000},
+  {2,  1850000, 1910000, 1930000, 1990000, 20, 386000},
+  {3,  1710000, 1785000, 1805000, 1880000, 20, 361000},
+  {5,   824000,  849000,  869000,  894000, 20, 173800},
+  {7,  2500000, 2570000, 2620000, 2690000, 20, 524000},
+  {8,   880000,  915000,  925000,  960000, 20, 185000},
+  {12,  698000,  716000,  728000,  746000, 20, 145800},
+  {20,  832000,  862000,  791000,  821000, 20, 158200},
+  {25, 1850000, 1915000, 1930000, 1995000, 20, 386000},
+  {28,  703000,  758000,  758000,  813000, 20, 151600},
+  {34, 2010000, 2025000, 2010000, 2025000, 20, 402000},
+  {38, 2570000, 2620000, 2570000, 2630000, 20, 514000},
+  {39, 1880000, 1920000, 1880000, 1920000, 20, 376000},
+  {40, 2300000, 2400000, 2300000, 2400000, 20, 460000},
+  {41, 2496000, 2690000, 2496000, 2690000,  3, 499200},
+  {50, 1432000, 1517000, 1432000, 1517000, 20, 286400},
+  {51, 1427000, 1432000, 1427000, 1432000, 20, 285400},
+  {66, 1710000, 1780000, 2110000, 2200000, 20, 422000},
+  {70, 1695000, 1710000, 1995000, 2020000, 20, 399000},
+  {71,  663000,  698000,  617000,  652000, 20, 123400},
+  {74, 1427000, 1470000, 1475000, 1518000, 20, 295000},
+  {75,     000,     000, 1432000, 1517000, 20, 286400},
+  {76,     000,     000, 1427000, 1432000, 20, 285400},
+  {77, 3300000, 4200000, 3300000, 4200000,  1, 620000},
+  {78, 3300000, 3800000, 3300000, 3800000,  1, 620000},
+  {79, 4400000, 5000000, 4400000, 5000000,  2, 693334},
+  {80, 1710000, 1785000,     000,     000, 20, 342000},
+  {81,  860000,  915000,     000,     000, 20, 176000},
+  {82,  832000,  862000,     000,     000, 20, 166400},
+  {83,  703000,  748000,     000,     000, 20, 140600},
+  {84, 1920000, 1980000,     000,     000, 20, 384000},
+  {86, 1710000, 1785000,     000,     000, 20, 342000}
+};
+
+void get_band(uint32_t downlink_frequency,   uint8_t *current_band,   int32_t *current_offset, lte_frame_type_t *current_type) {
+
+    int ind;
+    int64_t dl_freq_khz = downlink_frequency/1000;
+    for ( ind=0;
+          ind < sizeof(nr_bandtable) / sizeof(nr_bandtable[0]);
+          ind++) {
+
+      *current_band = nr_bandtable[ind].band;
+      LOG_I(PHY, "Scanning band %d, dl_min %"PRIu64", ul_min %"PRIu64"\n", ind, nr_bandtable[ind].dl_min,nr_bandtable[ind].ul_min);
+
+      if ( nr_bandtable[ind].dl_min <= dl_freq_khz && nr_bandtable[ind].dl_max >= dl_freq_khz ) {
+	*current_offset = (nr_bandtable[ind].ul_min - nr_bandtable[ind].dl_min)*1000;
+	if (*current_offset == 0)
+	  *current_type = TDD;
+	else
+	  *current_type = FDD;
+
+	LOG_I( PHY, "DL frequency %"PRIu32": band %d, frame_type %d, UL frequency %"PRIu32"\n",
+	       downlink_frequency, *current_band, *current_type, downlink_frequency+*current_offset);
+        break;
+      }
+    }
+
+    AssertFatal(ind != (sizeof(nr_bandtable) / sizeof(nr_bandtable[0])),
+	    "Can't find EUTRA band for frequency %d\n", downlink_frequency);
+
+}
+
+uint32_t to_nrarfcn(int nr_bandP, uint64_t dl_CarrierFreq, uint32_t bw)
+{
+
+  uint64_t dl_CarrierFreq_by_1k = dl_CarrierFreq / 1000;
+  int bw_kHz = bw / 1000;
+
+  int i;
+
+  LOG_I(MAC,"Searching for nr band %d DL Carrier frequency %llu bw %u\n",nr_bandP,(long long unsigned int)dl_CarrierFreq,bw);
+  AssertFatal(nr_bandP < 86, "nr_band %d > 86\n", nr_bandP);
+  for (i = 0; i < 30 && nr_bandtable[i].band != nr_bandP; i++);
+
+  AssertFatal(dl_CarrierFreq_by_1k >= nr_bandtable[i].dl_min,
+        "Band %d, bw %u : DL carrier frequency %llu kHz < %llu\n",
+	      nr_bandP, bw, (long long unsigned int)dl_CarrierFreq_by_1k,
+	      (long long unsigned int)nr_bandtable[i].dl_min);
+  AssertFatal(dl_CarrierFreq_by_1k <=
+        (nr_bandtable[i].dl_max - bw_kHz),
+        "Band %d, dl_CarrierFreq %llu bw %u: DL carrier frequency %llu kHz > %llu\n",
+	      nr_bandP, (long long unsigned int)dl_CarrierFreq,bw, (long long unsigned int)dl_CarrierFreq_by_1k,
+	      (long long unsigned int)(nr_bandtable[i].dl_max - bw_kHz));
+ 
+  int deltaFglobal;
+
+  if (dl_CarrierFreq < 3e9) deltaFglobal = 5;
+  else                      deltaFglobal = 15;
+
+  // This is equation before Table 5.4.2.1-1 in 38101-1-f30
+  // F_REF=F_REF_Offs + deltaF_Global(N_REF-NREF_REF_Offs)
+  return (((dl_CarrierFreq_by_1k - nr_bandtable[i].dl_min)/deltaFglobal) +
+	  nr_bandtable[i].N_OFFs_DL);
+}
+
+
+uint64_t from_nrarfcn(int nr_bandP, uint32_t dl_nrarfcn)
+{
+
+  int i;
+  int deltaFglobal;
+
+  if (nr_bandP < 77 || nr_bandP > 79) deltaFglobal = 5;
+  else                                deltaFglobal = 15;
+  
+  AssertFatal(nr_bandP < 87, "nr_band %d > 86\n", nr_bandP);
+  for (i = 0; i < 31 && nr_bandtable[i].band != nr_bandP; i++);
+  AssertFatal(dl_nrarfcn>=nr_bandtable[i].N_OFFs_DL,"dl_nrarfcn %u < N_OFFs_DL %llu\n",dl_nrarfcn, (long long unsigned int)nr_bandtable[i].N_OFFs_DL);
+ 
+  return 1000*(nr_bandtable[i].dl_min + (dl_nrarfcn - nr_bandtable[i].N_OFFs_DL) * deltaFglobal);
+	  
+}

targets/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp

@@ -597,10 +597,10 @@ static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp
 
         for (int i=0; i<cc; i++) buff_ptrs.push_back(buff[i]);
 
-        samples_received = s->rx_stream->recv(buff_ptrs, nsamps, s->rx_md);
+        samples_received = s->rx_stream->recv(buff_ptrs, nsamps, s->rx_md,1.0);
       } else {
         // receive a single channel (e.g. from connector RF A)
-        samples_received = s->rx_stream->recv(buff[0], nsamps, s->rx_md);
+        samples_received = s->rx_stream->recv(buff[0], nsamps, s->rx_md,1.0);
       }
     }
 

targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.106PRB.usrpn300.conf

@@ -254,7 +254,7 @@ RUs = (
          max_pdschReferenceSignalPower = -27;
          max_rxgain                    = 114;
          eNB_instances  = [0];
-	 sdr_addrs = "addr=192.168.10.2,second_addr=192.168.20.2,mgmt_addr=192.168.100.8";
+	 sdr_addrs = "addr=192.168.10.2,second_addr=192.168.20.2,mgmt_addr=192.168.100.8,clock_source=external,time_source=external";
 
     }
 );  

targets/RT/USER/nr-ue.c

@@ -150,64 +150,12 @@ void init_UE(int nb_inst);
 int32_t **rxdata;
 int32_t **txdata;
 
-#define KHz (1000UL)
-#define MHz (1000*KHz)
 #define SAIF_ENABLED
 
 #ifdef SAIF_ENABLED
   uint64_t  g_ue_rx_thread_busy = 0;
 #endif
 
-typedef struct eutra_band_s {
-  int16_t band;
-  uint32_t ul_min;
-  uint32_t ul_max;
-  uint32_t dl_min;
-  uint32_t dl_max;
-  lte_frame_type_t frame_type;
-} eutra_band_t;
-
-typedef struct band_info_s {
-  int nbands;
-  eutra_band_t band_info[100];
-} band_info_t;
-
-band_info_t bands_to_scan;
-
-static const eutra_band_t eutra_bands[] = {
-  {1,  1920000, 1980000, 2110000, 2170000, FDD},
-  {2,  1850000, 1910000, 1930000, 1990000, FDD},
-  {3,  1710000, 1785000, 1805000, 1880000, FDD},
-  {5,   824000,  849000,  869000,  894000, FDD},
-  {7,  2500000, 2570000, 2620000, 2690000, FDD},
-  {8,   880000,  915000,  925000,  960000, FDD},
-  {12,  698000,  716000,  728000,  746000, FDD},
-  {20,  832000,  862000,  791000,  821000, FDD},
-  {25, 1850000, 1915000, 1930000, 1995000, FDD},
-  {28,  703000,  758000,  758000,  813000, FDD},
-  {34, 2010000, 2025000, 2010000, 2025000, TDD},
-  {38, 2570000, 2620000, 2570000, 2630000, TDD},
-  {39, 1880000, 1920000, 1880000, 1920000, TDD},
-  {40, 2300000, 2400000, 2300000, 2400000, TDD},
-  {41, 2496000, 2690000, 2496000, 2690000, TDD},
-  {50, 1432000, 1517000, 1432000, 1517000, TDD},
-  {51, 1427000, 1432000, 1427000, 1432000, TDD},
-  {66, 1710000, 1780000, 2110000, 2200000, FDD},
-  {70, 1695000, 1710000, 1995000, 2020000, FDD},
-  {71,  663000,  698000,  617000,  652000, FDD},
-  {74, 1427000, 1470000, 1475000, 1518000, FDD},
-  {75,     000,     000, 1432000, 1517000, FDD},
-  {76,     000,     000, 1427000, 1432000, FDD},
-  {77, 3300000, 4200000, 3300000, 4200000, TDD},
-  {78, 3300000, 3800000, 3300000, 3800000, TDD},
-  {79, 4400000, 5000000, 4400000, 5000000, TDD},
-  {80, 1710000, 1785000,     000,     000, FDD},
-  {81,  860000,  915000,     000,     000, FDD},
-  {82,  832000,  862000,     000,     000, FDD},
-  {83,  703000,  748000,     000,     000, FDD},
-  {84, 1920000, 1980000,     000,     000, FDD},
-  {86, 1710000, 1785000,     000,     000, FDD}
-};
 
 PHY_VARS_NR_UE *init_nr_ue_vars(NR_DL_FRAME_PARMS *frame_parms,
                                 uint8_t UE_id,
@@ -354,29 +302,11 @@ static void *UE_thread_synch(void *arg) {
   init_thread(100000, 500000, FIFO_PRIORITY-1, &cpuset, threadname);
   UE->is_synchronized = 0;
 
-  if (UE->UE_scan == 0) {
-    int ind;
-    int64_t dl_freq_khz = downlink_frequency[0][0]/1000;
-    for ( ind=0;
-          ind < sizeof(eutra_bands) / sizeof(eutra_bands[0]);
-          ind++) {
-      current_band = eutra_bands[ind].band;
-      current_type = eutra_bands[ind].frame_type;
-      LOG_D(PHY, "Scanning band %d, dl_min %"PRIu32", ul_min %"PRIu32"\n", current_band, eutra_bands[ind].dl_min,eutra_bands[ind].ul_min);
-
-      if ( eutra_bands[ind].dl_min <= dl_freq_khz && eutra_bands[ind].dl_max >= dl_freq_khz ) {
-        for (i=0; i<4; i++)
-          uplink_frequency_offset[CC_id][i] = (eutra_bands[ind].ul_min - eutra_bands[ind].dl_min)*1000;
-
-        break;
-      }
-    }
-
+  printf("UE_scan %d\n",UE->UE_scan);
 
-    AssertFatal( ind < sizeof(eutra_bands) / sizeof(eutra_bands[0]), "Can't find EUTRA band for frequency");
+  if (UE->UE_scan == 0) {
 
-    UE->frame_parms.eutra_band = current_band;
-    UE->frame_parms.frame_type = current_type;
+    get_band(downlink_frequency[CC_id][0], &UE->frame_parms.eutra_band,   &uplink_frequency_offset[CC_id][0], &UE->frame_parms.frame_type);
 
     LOG_I( PHY, "[SCHED][UE] Check absolute frequency DL %"PRIu32", UL %"PRIu32" (oai_exit %d, rx_num_channels %d)\n",
            downlink_frequency[0][0], downlink_frequency[0][0]+uplink_frequency_offset[0][0],
@@ -397,7 +327,8 @@ static void *UE_thread_synch(void *arg) {
     sync_mode = pbch;
   } else {
     current_band=0;
-
+    LOG_E(PHY,"Fixme!\n");
+    /*
     for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
       downlink_frequency[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[CC_id].dl_min;
       uplink_frequency_offset[UE->rf_map.card][UE->rf_map.chain+i] =
@@ -407,6 +338,7 @@ static void *UE_thread_synch(void *arg) {
         downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i];
       openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;
     }
+    */
   }
 
   //    AssertFatal(UE->rfdevice.trx_start_func(&UE->rfdevice) == 0, "Could not start the device\n");
@@ -421,6 +353,7 @@ static void *UE_thread_synch(void *arg) {
     AssertFatal ( 0== pthread_mutex_unlock(&UE->proc.mutex_synch), "");
 
     switch (sync_mode) {
+      /*
       case pss:
         LOG_I(PHY,"[SCHED][UE] Scanning band %d (%d), freq %u\n",bands_to_scan.band_info[current_band].band, current_band,bands_to_scan.band_info[current_band].dl_min+current_offset);
         //lte_sync_timefreq(UE,current_band,bands_to_scan.band_info[current_band].dl_min+current_offset);
@@ -449,7 +382,7 @@ static void *UE_thread_synch(void *arg) {
         }
 
         break;
-
+      */
       case pbch:
 #if DISABLE_LOG_X
         printf("[UE thread Synch] Running Initial Synch (mode %d)\n",UE->mode);
@@ -767,10 +700,6 @@ static void *UE_thread_rxn_txnp4(void *arg) {
 
 void readFrame(PHY_VARS_NR_UE *UE,  openair0_timestamp *timestamp) {
   void *rxp[NB_ANTENNAS_RX];
-  void *dummy_tx[UE->frame_parms.nb_antennas_tx];
-
-  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-    dummy_tx[i]=malloc16_clear(UE->frame_parms.samples_per_subframe*4);
 
   for(int x=0; x<10; x++) {
     for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
@@ -781,37 +710,28 @@ void readFrame(PHY_VARS_NR_UE *UE,  openair0_timestamp *timestamp) {
                                             timestamp,
                                             rxp,
                                             UE->frame_parms.samples_per_subframe,
-                                            UE->frame_parms.nb_antennas_rx), "");
+                                            UE->frame_parms.nb_antennas_rx), "readFrame error");
   }
 
-  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-    free(dummy_tx[i]);
 }
 
 void trashFrame(PHY_VARS_NR_UE *UE, openair0_timestamp *timestamp) {
-  void *dummy_tx[UE->frame_parms.nb_antennas_tx];
-
-  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-    dummy_tx[i]=malloc16_clear(UE->frame_parms.samples_per_subframe*4);
-
   void *dummy_rx[UE->frame_parms.nb_antennas_rx];
 
   for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
     dummy_rx[i]=malloc16(UE->frame_parms.samples_per_subframe*4);
 
   for (int sf=0; sf<NR_NUMBER_OF_SUBFRAMES_PER_FRAME; sf++) {
-    //      printf("Reading dummy sf %d\n",sf);
-    UE->rfdevice.trx_read_func(&UE->rfdevice,
-                               timestamp,
-                               dummy_rx,
-                               UE->frame_parms.samples_per_subframe,
-                               UE->frame_parms.nb_antennas_rx);
-    usleep(500); // this sleep improves in the case of simulated RF and doesn't harm with true radio
+    //printf("Reading dummy sf %d\n",sf);
+    AssertFatal( UE->frame_parms.samples_per_subframe ==
+		 UE->rfdevice.trx_read_func(&UE->rfdevice,
+					    timestamp,
+					    dummy_rx,
+					    UE->frame_parms.samples_per_subframe,
+					    UE->frame_parms.nb_antennas_rx), "trashFrame error");
+    //usleep(500); // this sleep improves in the case of simulated RF and doesn't harm with true radio
   }
 
-  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-    free(dummy_tx[i]);
-
   for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
     free(dummy_rx[i]);
 }
@@ -819,10 +739,6 @@ void trashFrame(PHY_VARS_NR_UE *UE, openair0_timestamp *timestamp) {
 void syncInFrame(PHY_VARS_NR_UE *UE, openair0_timestamp *timestamp) {
   if (UE->no_timing_correction==0) {
     LOG_I(PHY,"Resynchronizing RX by %d samples (mode = %d)\n",UE->rx_offset,UE->mode);
-    void *dummy_tx[UE->frame_parms.nb_antennas_tx];
-
-    for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-      dummy_tx[i]=malloc16_clear(UE->frame_parms.samples_per_subframe*4);
 
     for ( int size=UE->rx_offset ; size > 0 ; size -= UE->frame_parms.samples_per_subframe ) {
       int unitTransfer=size>UE->frame_parms.samples_per_subframe ? UE->frame_parms.samples_per_subframe : size ;
@@ -831,11 +747,8 @@ void syncInFrame(PHY_VARS_NR_UE *UE, openair0_timestamp *timestamp) {
                                              timestamp,
                                              (void **)UE->common_vars.rxdata,
                                              unitTransfer,
-                                             UE->frame_parms.nb_antennas_rx),"");
+                                             UE->frame_parms.nb_antennas_rx),"syncInFrame error");
     }
-
-    for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-      free(dummy_tx[i]);
   }
 }
 
@@ -964,7 +877,7 @@ void *UE_thread(void *arg) {
                                                 &timestamp,
                                                 (void **)UE->common_vars.rxdata,
                                                 UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0,
-                                                UE->frame_parms.nb_antennas_rx),"");
+                                                UE->frame_parms.nb_antennas_rx),"first symbol read error");
         //write_output("txdata_sym.m", "txdata_sym", UE->common_vars.rxdata[0], (UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0), 1, 1);
         //nr_slot_fep(UE,0, 0, 0, 1, NR_PDCCH_EST);
       } //UE->mode != loop_through_memory
@@ -1043,7 +956,7 @@ void *UE_thread(void *arg) {
                                              &timestamp,
                                              rxp,
                                              readBlockSize,
-                                             UE->frame_parms.nb_antennas_rx),"");
+                                             UE->frame_parms.nb_antennas_rx),"read error");
       AssertFatal( writeBlockSize ==
                    UE->rfdevice.trx_write_func(&UE->rfdevice,
                        timestamp+
@@ -1053,7 +966,7 @@ void *UE_thread(void *arg) {
                        txp,
                        writeBlockSize,
                        UE->frame_parms.nb_antennas_tx,
-                       1),"");
+                       1),"write error");
 
       if( slot_nr==(nb_slot_frame-1)) {
         // read in first symbol of next frame and adjust for timing drift
@@ -1065,7 +978,7 @@ void *UE_thread(void *arg) {
                                                  &timestamp,
                                                  (void **)UE->common_vars.rxdata,
                                                  first_symbols,
-                                                 UE->frame_parms.nb_antennas_rx),"");
+                                                 UE->frame_parms.nb_antennas_rx),"first symbols read error");
         else
           LOG_E(PHY,"can't compensate: diff =%d\n", first_symbols);
       }

targets/RT/USER/nr-uesoftmodem.c

@@ -932,14 +932,14 @@ int main( int argc, char **argv ) {
 
       LOG_I(PHY,"Set nb_rx_antenna %d , nb_tx_antenna %d \n",frame_parms[CC_id]->nb_antennas_rx, frame_parms[CC_id]->nb_antennas_tx);
   
-    //init_ul_hopping(frame_parms[CC_id]);
-    //phy_init_nr_top(frame_parms[CC_id]);
-  }
+      get_band(downlink_frequency[CC_id][0], &frame_parms[CC_id]->eutra_band,   &uplink_frequency_offset[CC_id][0], &frame_parms[CC_id]->frame_type);
 
-  for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
-        //init prach for openair1 test
-        // prach_fmt = get_prach_fmt(frame_parms->prach_config_common.prach_ConfigInfo.prach_ConfigIndex, frame_parms->frame_type);
-        // N_ZC = (prach_fmt <4)?839:139;
+      //init_ul_hopping(frame_parms[CC_id]);
+      //phy_init_nr_top(frame_parms[CC_id]);
+      
+      //init prach for openair1 test
+      // prach_fmt = get_prach_fmt(frame_parms->prach_config_common.prach_ConfigInfo.prach_ConfigIndex, frame_parms->frame_type);
+      // N_ZC = (prach_fmt <4)?839:139;
   }
 
   NB_UE_INST=1;