Integration 2020 wk48 2

MR945 : nr prach fr2
- Introduction of the PRACH frontend for FR2 (120kHz SCS, 32 and 66 PRB). 
- Tested with nr_prachsim and testcases added to test_case_list.xml also included some fixes for FR1, 
when prach occasion > 0 (small difference in Ncp)

MR950 : DL and UL PTRS for 5G NR

MR971 : Correct NDI + Minor MAC subPDU handling improvements
Fixes the issue : Ping in develop was unusually high (70+ms). The issue was that TA was scheduled in the second slot (of the two we currently schedule), but NDI was toggled for the first one. 
Other improvements:
- Correctly put padding MAC subPDU
- Only use subPDU DLSCH long header if length >= 256B
- Calculate TBS in DL pre-processor considering header and TA CE overhead.
- Improve some of the logging (LOG_D)
- re-enable TA

MR970 : uci gnb mac functions file
- Moved gNB MAC UCI related functions in a new file

MR972 : Bugfix nr rate matching assertion
- Fixes the assertion happening in rate matching of pdsch during iperf test.

MR975 : File openning in rrc_gNB_internal
- Only allow file opening in rrc_gNB-internal.c in phytest mode

MR977 : NR UE DCI sanity checks and fixes
These changes resolve a few stability issues and errors in NR UE
- Added sanity check for pucch_resource_indicator received in DL DCI, which resolves SEGV in select_pucch_resource() and check_pucch_format()
- Additional sanity checks included to catch false or erroneous DCI received
- Wrong MCS table calculation and error in accessing ul_config_request at UE resolved

ci-scripts/xml_files/fr1_ran_ue_proc.xml

@@ -32,9 +32,13 @@
  000001
  050000
  050001
+ 050002
+ 050003
+ 000001
+ 010002
+ 000001
  070001
  070000
- 010002
  010003
 	</TestCaseRequestedList>
 	<TestCaseExclusionList></TestCaseExclusionList>
@@ -89,16 +93,30 @@
 		<class>Ping</class>
 		<desc>Ping: 20pings in 20sec</desc>
 		<ping_args>-c 20</ping_args>
-		<ping_packetloss_threshold>50</ping_packetloss_threshold>
+		<ping_packetloss_threshold>0</ping_packetloss_threshold>
 	</testCase>
 
 	<testCase id="050001">
 		<class>Ping</class>
 		<desc>Ping: 5pings in 1sec</desc>
 		<ping_args>-c 5 -i 0.2</ping_args>
-		<ping_packetloss_threshold>50</ping_packetloss_threshold>
+		<ping_packetloss_threshold>0</ping_packetloss_threshold>
 	</testCase>
 
+	<testCase id="050002">
+		<class>Ping</class>
+		<desc>Ping: 100pings in 20sec</desc>
+		<ping_args>-c 100 -i 0.2</ping_args>
+		<ping_packetloss_threshold>0</ping_packetloss_threshold>
+	</testCase>
+
+	<testCase id="050003">$
+	<class>Ping</class>$
+	<desc>Ping: 100pings in 20sec size 1000</desc>$
+	<ping_args>-c 100 -i 0.2 -s 1000</ping_args>$
+	<ping_packetloss_threshold>0</ping_packetloss_threshold>$
+	</testCase>$
+
 	<testCase id="070000">
 		<class>Terminate_eNB</class>
 		<desc>Terminate eNB</desc>

cmake_targets/CMakeLists.txt

@@ -2087,6 +2087,7 @@ set (MAC_NR_SRC
   ${NR_GNB_MAC_DIR}/gNB_scheduler_ulsch.c
   ${NR_GNB_MAC_DIR}/gNB_scheduler_primitives.c
   ${NR_GNB_MAC_DIR}/gNB_scheduler_phytest.c
+  ${NR_GNB_MAC_DIR}/gNB_scheduler_uci.c
   ${NR_GNB_MAC_DIR}/gNB_scheduler_RA.c
  )
 

cmake_targets/autotests/test_case_list.xml

@@ -1095,7 +1095,10 @@
                                  (Test10: 106 PRBs 50 PDSCH-PRBs MCS Index 16),
                                  (Test11: HARQ test 25% TP (4 rounds),
                                  (Test12: HARQ test 33% TP (3 rounds),
-                                 (Test13: HARQ test 50% TP (2 rounds)</desc>
+                                 (Test13: HARQ test 50% TP (2 rounds),
+                                 (Test14: 3 PTRS, 8 Interpolated Symbols),
+                                 (Test15: 6 PTRS, 5 Interpolated Symbols),
+                                 (Test16: 11 PTRS, 0 Interpolated Symbols)</desc>
       <pre_compile_prog></pre_compile_prog>
       <compile_prog>$OPENAIR_DIR/cmake_targets/build_oai</compile_prog>
       <compile_prog_args> --phy_simulators  -c </compile_prog_args>
@@ -1114,8 +1117,11 @@
                   -n100 -e16 -s10 
                   -n100 -s1 -t25
                   -n100 -s1 -t33
-                  -n100 -s1 -t50</main_exec_args>
-      <tags>nr_dlsim.test1 nr_dlsim.test2 nr_dlsim.test3 nr_dlsim.test4 nr_dlsim.test5 nr_dlsim.test6 nr_dlsim.test7 nr_dlsim.test8 nr_dlsim.test9 nr_dlsim.test10 nr_dlsim.test11 nr_dlsim.test12 nr_dlsim.test13</tags>
+                  -n100 -s1 -t50
+                  -n100 -s5 -T 2 2 2
+                  -n100 -s5 -T 2 1 2
+                  -n100 -s5 -T 2 0 4</main_exec_args>
+      <tags>nr_dlsim.test1 nr_dlsim.test2 nr_dlsim.test3 nr_dlsim.test4 nr_dlsim.test5 nr_dlsim.test6 nr_dlsim.test7 nr_dlsim.test8 nr_dlsim.test9 nr_dlsim.test10 nr_dlsim.test11 nr_dlsim.test12 nr_dlsim.test13 nr_dlsim.test14 nr_dlsim.test15 nr_dlsim.test16</tags>
       <search_expr_true>PDSCH test OK</search_expr_true>
       <search_expr_false>segmentation fault|assertion|exiting|fatal</search_expr_false>
       <nruns>3</nruns>
@@ -1302,10 +1308,12 @@
 
     <testCase id="015112">
       <class>execution</class>
-      <desc>nr_prachsim Test cases. (Test1: 106 PRBs - Prach format A2),
-                                    (Test2: 217 PRBs - Prach format A2),
-                                    (Test3: 273 PRBs - Prach format A2),
-				    (Test4: 106 PRBs - Prach format 0)</desc>
+      <desc>nr_prachsim Test cases. (Test1: 30kHz SCS, 106 PRBs, Prach format A2),
+                                    (Test2: 30kHz SCS, 217 PRBs, Prach format A2),
+                                    (Test3: 30kHz SCS, 273 PRBs, Prach format A2),
+				    (Test4: 30kHz SCS, 106 PRBs, Prach format 0),
+                                    (Test5: 120kHz SCS, 32 PRBs, Prach format A2),
+                                    (Test6: 120kHz SCS, 66 PRBs, Prach format A2)</desc>
       <pre_compile_prog></pre_compile_prog>
       <compile_prog>$OPENAIR_DIR/cmake_targets/build_oai</compile_prog>
       <compile_prog_args> --phy_simulators -c </compile_prog_args>
@@ -1315,8 +1323,10 @@
       <main_exec_args>-a -s -30 -n 100 -p 63 -R 106
                       -a -s -30 -n 100 -p 63 -R 217
                       -a -s -30 -n 100 -p 63 -R 273
-		      -a -s -30 -n 100 -p 63 -R 106 -c 4</main_exec_args>
-      <tags>nr_prachsim.test1 nr_prachsim.test2 nr_prachsim.test3 nr_prachsim.test4</tags>
+		      -a -s -30 -n 100 -p 63 -R 106 -c 4
+		      -a -s -30 -n 100 -p 32 -R 32 -m 3 -c52 
+		      -a -s -30 -n 100 -p 32 -R 66 -m 3 -c52</main_exec_args>
+      <tags>nr_prachsim.test1 nr_prachsim.test2 nr_prachsim.test3 nr_prachsim.test4 nr_prachsim.test5 nr_prachsim.test6</tags>
       <search_expr_true>PRACH test OK</search_expr_true>
       <search_expr_false>segmentation fault|assertion|exiting|fatal</search_expr_false>
       <nruns>3</nruns>

nfapi/open-nFAPI/nfapi/public_inc/fapi_nr_ue_interface.h

@@ -472,6 +472,21 @@ typedef struct {
   uint8_t cbgti;
   uint8_t codeBlockGroupFlushIndicator;
   //  to be check the fields needed to L1 with NR_DL_UE_HARQ_t and NR_UE_DLSCH_t
+  // PTRS [TS38.214, sec 5.1.6.3]
+  /// PT-RS antenna ports [TS38.214, sec 5.1.6.3] [TS38.211, table 7.4.1.2.2-1] Bitmap occupying the 6 LSBs with: bit 0: antenna port 1000 bit 5: antenna port 1005 and for each bit 0: PTRS port not used 1: PTRS port used
+  uint8_t PTRSPortIndex ;
+  /// PT-RS time density [TS38.214, table 5.1.6.3-1] 0: 1 1: 2 2: 4
+  uint8_t PTRSTimeDensity;
+  /// PT-RS frequency density [TS38.214, table 5.1.6.3-2] 0: 2 1: 4
+  uint8_t PTRSFreqDensity;
+  /// PT-RS resource element offset [TS38.211, table 7.4.1.2.2-1] Value: 0->3
+  uint8_t PTRSReOffset;
+  ///  PT-RS-to-PDSCH EPRE ratio [TS38.214, table 4.1-2] Value :0->3
+  uint8_t nEpreRatioOfPDSCHToPTRS;
+  /// MCS table for this DLSCH
+  uint8_t mcs_table;
+
+  uint16_t pduBitmap;
 } fapi_nr_dl_config_dlsch_pdu_rel15_t;
 
 typedef struct {
@@ -783,7 +798,7 @@ typedef struct {
 } fapi_nr_pusch_power_control_t;
 
 typedef enum {tx_config_codebook = 1, tx_config_nonCodebook = 2} tx_config_t;
-typedef enum {transform_precoder_disabled = 0, transform_precoder_enabled = 1} transform_precoder_t;
+typedef enum {transform_precoder_enabled = 0, transform_precoder_disabled = 1} transform_precoder_t;
 typedef enum {
   codebook_subset_fullyAndPartialAndNonCoherent = 1,
   codebook_subset_partialAndNonCoherent = 2,

openair1/PHY/INIT/nr_init.c

@@ -431,11 +431,18 @@ void nr_phy_config_request_sim(PHY_VARS_gNB *gNB,
   //gNB_config->subframe_config.dl_cyclic_prefix_type.value = (fp->Ncp == NORMAL) ? NFAPI_CP_NORMAL : NFAPI_CP_EXTENDED;
 
   gNB->mac_enabled   = 1;
-  fp->dl_CarrierFreq = 3500000000;//from_nrarfcn(gNB_config->nfapi_config.rf_bands.rf_band[0],gNB_config->nfapi_config.nrarfcn.value);
-  fp->ul_CarrierFreq = 3500000000;//fp->dl_CarrierFreq - (get_uldl_offset(gNB_config->nfapi_config.rf_bands.rf_band[0])*100000);
-  fp->nr_band = 78;
-//  fp->threequarter_fs= 0;
-
+  if (mu==1) {
+    fp->dl_CarrierFreq = 3500000000;//from_nrarfcn(gNB_config->nfapi_config.rf_bands.rf_band[0],gNB_config->nfapi_config.nrarfcn.value);
+    fp->ul_CarrierFreq = 3500000000;//fp->dl_CarrierFreq - (get_uldl_offset(gNB_config->nfapi_config.rf_bands.rf_band[0])*100000);
+    fp->nr_band = 78;
+    //  fp->threequarter_fs= 0;
+  } else if (mu==3) {
+    fp->dl_CarrierFreq = 27524520000;//from_nrarfcn(gNB_config->nfapi_config.rf_bands.rf_band[0],gNB_config->nfapi_config.nrarfcn.value);
+    fp->ul_CarrierFreq = 27524520000;//fp->dl_CarrierFreq - (get_uldl_offset(gNB_config->nfapi_config.rf_bands.rf_band[0])*100000);
+    fp->nr_band = 261;
+    //  fp->threequarter_fs= 0;
+  }
+    
   gNB_config->carrier_config.dl_bandwidth.value = config_bandwidth(mu, N_RB_DL, fp->nr_band);
 
   nr_init_frame_parms(gNB_config, fp);

openair1/PHY/INIT/nr_init_ue.c

@@ -393,6 +393,9 @@ void phy_init_nr_ue__PDSCH(NR_UE_PDSCH *const pdsch,
   //pdsch->dl_ch_rho2_ext         = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
   pdsch->dl_ch_mag0             = (int32_t **)malloc16_clear( 8*sizeof(int32_t *) );
   pdsch->dl_ch_magb0            = (int32_t **)malloc16_clear( 8*sizeof(int32_t *) );
+  pdsch->ptrs_phase_per_slot    = (int32_t **)malloc16_clear( 8*sizeof(int32_t *) );
+  pdsch->ptrs_re_per_slot       = (int32_t **)malloc16_clear( 8*sizeof(int32_t *) );
+  pdsch->dl_ch_ptrs_estimates_ext = (int32_t **)malloc16_clear( 8*sizeof(int32_t *) );
   // the allocated memory size is fixed:
   AssertFatal( fp->nb_antennas_rx <= 2, "nb_antennas_rx > 2" );
 
@@ -413,6 +416,9 @@ void phy_init_nr_ue__PDSCH(NR_UE_PDSCH *const pdsch,
       //pdsch->dl_ch_rho2_ext[idx]          = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
       pdsch->dl_ch_mag0[idx]              = (int32_t *)malloc16_clear( sizeof(int32_t) * num );
       pdsch->dl_ch_magb0[idx]             = (int32_t *)malloc16_clear( sizeof(int32_t) * num );
+      pdsch->ptrs_re_per_slot[idx]        = (int32_t *)malloc16_clear(sizeof(int32_t) * 14);
+      pdsch->ptrs_phase_per_slot[idx]     = (int32_t *)malloc16_clear( sizeof(int32_t) * 14 );
+      pdsch->dl_ch_ptrs_estimates_ext[idx]= (int32_t *)malloc16_clear( sizeof(int32_t) * num);
     }
   }
 }

openair1/PHY/NR_ESTIMATION/nr_ul_estimation.h

@@ -53,28 +53,10 @@ int nr_est_timing_advance_pusch(PHY_VARS_gNB* phy_vars_gNB, int UE_id);
 
 
 void nr_pusch_ptrs_processing(PHY_VARS_gNB *gNB,
+                              NR_DL_FRAME_PARMS *frame_parms,
                               nfapi_nr_pusch_pdu_t *rel15_ul,
                               uint8_t ulsch_id,
                               uint8_t nr_tti_rx,
-                              uint8_t dmrs_symbol_flag,
                               unsigned char symbol,
                               uint32_t nb_re_pusch);
-
-void nr_pusch_phase_estimation(NR_DL_FRAME_PARMS *frame_parms,
-                               nfapi_nr_pusch_pdu_t *rel15_ul,
-                               int16_t *ptrs_ch_p,
-                               unsigned char Ns,
-                               unsigned char symbol,
-                               int16_t *rxF_comp,
-                               uint32_t ***ptrs_gold_seq,
-                               int16_t *error_est,
-                               uint16_t  *ptrs_sc);
-
-void nr_pusch_phase_interpolation(int16_t *error_est,
-                                  uint8_t start_symbol,
-                                  uint8_t end_symbol);
-
-int nr_ptrs_find_next_estimate(int16_t *error_est,
-                               uint8_t counter,
-                               uint8_t end_symbol);
 #endif

openair1/PHY/NR_REFSIG/dmrs_nr.c

@@ -364,14 +364,14 @@ void generate_dmrs_pbch(uint32_t dmrs_pbch_bitmap[DMRS_PBCH_I_SSB][DMRS_PBCH_N_H
 #endif
 }
 /* return the position of next dmrs symbol in a slot */
-int get_next_dmrs_symbol_in_slot(uint16_t  ul_dmrs_symb_pos, uint8_t counter, uint8_t end_symbol)
+int8_t get_next_dmrs_symbol_in_slot(uint16_t  ul_dmrs_symb_pos, uint8_t counter, uint8_t end_symbol)
 {
-  for(uint8_t symbol = counter; symbol < end_symbol; symbol++)
-    if((ul_dmrs_symb_pos >>symbol)&0x01 )
-    {
+  for(uint8_t symbol = counter; symbol < end_symbol; symbol++) {
+    if((ul_dmrs_symb_pos >> symbol) & 0x01 ) {
       return symbol;
     }
-  return 0;
+  }
+  return -1;
 }
 
 
@@ -379,9 +379,30 @@ int get_next_dmrs_symbol_in_slot(uint16_t  ul_dmrs_symb_pos, uint8_t counter, ui
 uint8_t get_dmrs_symbols_in_slot(uint16_t l_prime_mask,  uint16_t nb_symb)
 {
   uint8_t tmp = 0;
-  for (int i = 0; i < nb_symb; i++)
-  {
+  for (int i = 0; i < nb_symb; i++) {
     tmp += (l_prime_mask >> i) & 0x01;
   }
   return tmp;
 }
+
+/* return the position of valid dmrs symbol in a slot for channel compensation */
+int8_t get_valid_dmrs_idx_for_channel_est(uint16_t  dmrs_symb_pos, uint8_t counter)
+{
+  int8_t  symbIdx = -1;
+  /* if current symbol is DMRS then return this index */
+  if(is_dmrs_symbol(counter,  dmrs_symb_pos ) ==1) {
+    return counter;
+  }
+  /* find previous DMRS symbol */
+  for(int8_t symbol = counter;symbol >=0 ; symbol--) {
+    if((1<<symbol & dmrs_symb_pos)> 0) {
+      symbIdx = symbol;
+      break;
+    }
+  }
+  /* if there is no previous dmrs available then find the next possible*/
+  if(symbIdx == -1) {
+    symbIdx = get_next_dmrs_symbol_in_slot(dmrs_symb_pos,counter,15);
+  }
+  return symbIdx;
+}

openair1/PHY/NR_REFSIG/dmrs_nr.h

@@ -62,6 +62,12 @@ uint8_t allowed_xlsch_re_in_dmrs_symbol(uint16_t k,
                                         uint8_t numDmrsCdmGrpsNoData,
                                         uint8_t dmrs_type);
 
+void nr_gen_ref_conj_symbols(uint32_t *in, uint32_t length, int16_t *output, uint16_t offset, int mod_order);
+int8_t get_next_dmrs_symbol_in_slot(uint16_t  ul_dmrs_symb_pos, uint8_t counter, uint8_t end_symbol);
+uint8_t get_dmrs_symbols_in_slot(uint16_t l_prime_mask,  uint16_t nb_symb);
+int8_t get_valid_dmrs_idx_for_channel_est(uint16_t  dmrs_symb_pos, uint8_t counter);
+
+static inline uint8_t is_dmrs_symbol(uint8_t l, uint16_t dmrsSymbMask ) { return ((dmrsSymbMask >> l) & 0x1); }
 #undef EXTERN
 
 #endif /* DMRS_NR_H */

openair1/PHY/NR_REFSIG/nr_gold_ue.c

@@ -107,9 +107,7 @@ void nr_gold_pdcch(PHY_VARS_NR_UE* ue,
 }
 
 void nr_gold_pdsch(PHY_VARS_NR_UE* ue,
-                   unsigned short lbar,
-                   unsigned short *n_idDMRS,
-                   unsigned short length_dmrs)
+                   unsigned short *n_idDMRS)
 {
   unsigned char ns,l;
   unsigned int n,x1,x2,x2tmp0;
@@ -129,12 +127,12 @@ void nr_gold_pdsch(PHY_VARS_NR_UE* ue,
 
     for (ns=0; ns<20; ns++) {
 
-      for (l=0; l<length_dmrs; l++) {
+      for (l=0; l<14; l++) {
 
-    	x2tmp0 = ((14*ns+(lbar+l)+1)*((nid<<1)+1))<<17;
+        x2tmp0 = ((14*ns+l+1)*((nid<<1)+1))<<17;
         x2 = (x2tmp0+(nid<<1)+nscid)%(1<<31);  //cinit
-	LOG_D(PHY,"UE DMRS slot %d, symb %d, lbar %d, x2 %x, nscid %d\n",ns,l,lbar,x2,nscid);
-                //printf("ns %d gold pdsch x2 %d\n",ns,x2);
+        LOG_D(PHY,"UE DMRS slot %d, symb %d, x2 %x, nscid %d\n",ns,l,x2,nscid);
+        //printf("ns %d gold pdsch x2 %d\n",ns,x2);
 
         x1 = 1+ (1<<31);
         x2=x2 ^ ((x2 ^ (x2>>1) ^ (x2>>2) ^ (x2>>3))<<31);
@@ -145,7 +143,7 @@ void nr_gold_pdsch(PHY_VARS_NR_UE* ue,
           x1 = x1 ^ (x1<<31) ^ (x1<<28);
           x2 = (x2>>1) ^ (x2>>2) ^ (x2>>3) ^ (x2>>4);
           x2 = x2 ^ (x2<<31) ^ (x2<<30) ^ (x2<<29) ^ (x2<<28);
-            //printf("x1 : %x, x2 : %x\n",x1,x2);
+          //printf("x1 : %x, x2 : %x\n",x1,x2);
         }
 
         for (n=0; n<NR_MAX_PDSCH_DMRS_INIT_LENGTH_DWORD; n++) {
@@ -154,8 +152,8 @@ void nr_gold_pdsch(PHY_VARS_NR_UE* ue,
           x2 = (x2>>1) ^ (x2>>2) ^ (x2>>3) ^ (x2>>4);
           x2 = x2 ^ (x2<<31) ^ (x2<<30) ^ (x2<<29) ^ (x2<<28);
           ue->nr_gold_pdsch[nscid][ns][l][n] = x1^x2;
-            // if ((ns==2)&&(l==0))
-            //printf("n=%d : c %x\n",n,x1^x2);
+          // if ((ns==2)&&(l==0))
+          //printf("n=%d : c %x\n",n,x1^x2);
         }
 
       }

openair1/PHY/NR_REFSIG/nr_refsig.h

@@ -53,10 +53,6 @@ int nr_pusch_dmrs_rx(PHY_VARS_gNB *gNB,
                      uint8_t dmrs_type);
 
 void init_scrambling_luts(void);
-void nr_gen_ref_conj_symbols(uint32_t *in, uint32_t length, int16_t *output, uint16_t offset, int mod_order);
-uint8_t get_next_dmrs_symbol_in_slot(uint16_t  ul_dmrs_symb_pos, uint8_t counter, uint8_t end_symbol);
-uint8_t get_dmrs_symbols_in_slot(uint16_t l_prime_mask,  uint16_t nb_symb);
-
 void nr_generate_modulation_table(void);
 
 extern __m64 byte2m64_re[256];

openair1/PHY/NR_REFSIG/ptrs_nr.h

@@ -80,6 +80,31 @@ uint8_t is_ptrs_subcarrier(uint16_t k,
 
 static inline uint8_t is_ptrs_symbol(uint8_t l, uint16_t ptrs_symbols) { return ((ptrs_symbols >> l) & 1); }
 
-
-
+uint8_t get_ptrs_symbols_in_slot(uint16_t l_prime_mask, uint16_t start_symb, uint16_t nb_symb);
+int8_t get_next_ptrs_symbol_in_slot(uint16_t  ptrsSymbPos, uint8_t counter, uint8_t nb_symb);
+int8_t get_next_estimate_in_slot(uint16_t  ptrsSymbPos,uint16_t  dmrsSymbPos, uint8_t counter,uint8_t nb_symb);
+
+int8_t nr_ptrs_process_slot(uint16_t dmrsSymbPos,
+                            uint16_t ptrsSymbPos,
+                            int16_t *estPerSymb,
+                            uint16_t startSymbIdx,
+                            uint16_t noSymb
+                            );
+/*  general function to estimate common phase error based upon PTRS */
+void nr_ptrs_cpe_estimation(uint8_t K_ptrs,
+                            uint8_t ptrsReOffset,
+                            uint8_t dmrsConfigType,
+                            uint16_t nb_rb,
+                            uint16_t rnti,
+                            int16_t *ptrs_ch_p,
+                            unsigned char Ns,
+                            unsigned char symbol,
+                            uint16_t ofdm_symbol_size,
+                            int16_t *rxF_comp,
+                            uint32_t *gold_seq,
+                            int16_t *error_est,
+                            int32_t *ptrs_sc);
+
+void get_slope_from_estimates(uint8_t start, uint8_t end, int16_t *est_p, double *slope_p);
+void ptrs_estimate_from_slope(int16_t *error_est, double *slope_p, uint8_t start, uint8_t end);
 #endif /* PTRS_NR_H */

openair1/PHY/NR_REFSIG/refsig_defs_ue.h

@@ -61,9 +61,7 @@ void nr_gold_pdcch(PHY_VARS_NR_UE* ue,
                    unsigned short length_dmrs);
 
 void nr_gold_pdsch(PHY_VARS_NR_UE* ue,
-                   unsigned short lbar,
-                   unsigned short *n_idDMRS,
-                   unsigned short length_dmrs);
+                   unsigned short *n_idDMRS);
 
 void nr_init_pusch_dmrs(PHY_VARS_NR_UE* ue,
                         uint16_t *N_n_scid,

openair1/PHY/NR_TRANSPORT/nr_dlsch.c

@@ -35,7 +35,9 @@
 #include "nr_sch_dmrs.h"
 #include "PHY/MODULATION/nr_modulation.h"
 #include "PHY/NR_REFSIG/dmrs_nr.h"
+#include "PHY/NR_REFSIG/ptrs_nr.h"
 #include "common/utils/LOG/vcd_signal_dumper.h"
+#include "LAYER2/NR_MAC_gNB/mac_proto.h"
 
 //#define DEBUG_DLSCH
 //#define DEBUG_DLSCH_MAPPING
@@ -117,8 +119,8 @@ uint8_t nr_generate_pdsch(PHY_VARS_gNB *gNB,
   uint32_t ***pdsch_dmrs = gNB->nr_gold_pdsch_dmrs[slot];
   int32_t** txdataF = gNB->common_vars.txdataF;
   int16_t amp = AMP;
-  NR_DL_FRAME_PARMS *frame_parms = &gNB->frame_parms;
   int xOverhead = 0;
+  NR_DL_FRAME_PARMS *frame_parms = &gNB->frame_parms;
   time_stats_t *dlsch_encoding_stats=&gNB->dlsch_encoding_stats;
   time_stats_t *dlsch_scrambling_stats=&gNB->dlsch_scrambling_stats;
   time_stats_t *dlsch_modulation_stats=&gNB->dlsch_modulation_stats;
@@ -152,13 +154,31 @@ uint8_t nr_generate_pdsch(PHY_VARS_gNB *gNB,
       nb_re_dmrs = 4*rel15->numDmrsCdmGrpsNoData;
       n_dmrs = ((rel15->rbSize+rel15->rbStart)*4)<<1;
     }
-    uint16_t nb_re;
-    nb_re = ((12*rel15->NrOfSymbols)-nb_re_dmrs-xOverhead)*rel15->rbSize*rel15->nrOfLayers;
+
+    uint16_t dmrs_symbol_map = rel15->dlDmrsSymbPos;//single DMRS: 010000100 Double DMRS 110001100
+    uint8_t dmrs_len = get_num_dmrs(rel15->dlDmrsSymbPos);
+    uint16_t nb_re = ((12*rel15->NrOfSymbols)-nb_re_dmrs*dmrs_len-xOverhead)*rel15->rbSize*rel15->nrOfLayers;
     uint8_t Qm = rel15->qamModOrder[0];
     uint32_t encoded_length = nb_re*Qm;
     int16_t mod_dmrs[14][n_dmrs] __attribute__ ((aligned(16)));
-    
-    
+
+    /* PTRS */
+    uint16_t beta_ptrs = 1;
+    uint8_t ptrs_symbol = 0;
+    uint16_t dlPtrsSymPos = 0;
+    uint16_t n_ptrs = 0;
+    uint16_t ptrs_idx = 0;
+    uint8_t is_ptrs_re = 0;
+    if(rel15->pduBitmap & 0x1) {
+      set_ptrs_symb_idx(&dlPtrsSymPos,
+                          rel15->NrOfSymbols,
+                          rel15->StartSymbolIndex,
+                          1<<rel15->PTRSTimeDensity,
+                          rel15->dlDmrsSymbPos);
+      n_ptrs = (rel15->rbSize + rel15->PTRSFreqDensity - 1)/rel15->PTRSFreqDensity;
+    }
+    int16_t mod_ptrs[n_ptrs<<1] __attribute__ ((aligned(16)));
+
     /// CRC, coding, interleaving and rate matching
     AssertFatal(harq->pdu!=NULL,"harq->pdu is null\n");
     start_meas(dlsch_encoding_stats);
@@ -251,22 +271,21 @@ uint8_t nr_generate_pdsch(PHY_VARS_gNB *gNB,
 
     /// DMRS QPSK modulation
     for (int l=rel15->StartSymbolIndex; l<rel15->StartSymbolIndex+rel15->NrOfSymbols; l++) {
-      if (rel15->dlDmrsSymbPos & (1 << l))
+      if (rel15->dlDmrsSymbPos & (1 << l)) {
         nr_modulation(pdsch_dmrs[l][0], n_dmrs, DMRS_MOD_ORDER, mod_dmrs[l]); // currently only codeword 0 is modulated. Qm = 2 as DMRS is QPSK modulated
-    }
 
 #ifdef DEBUG_DLSCH
-    l0 = get_l0(rel15->dlDmrsSymbPos);
-    printf("DMRS modulation (single symbol %d, %d symbols, type %d):\n", l0, n_dmrs>>1, dmrs_Type);
-    for (int i=0; i<n_dmrs>>4; i++) {
-      for (int j=0; j<8; j++) {
-        printf("%d %d\t", mod_dmrs[((i<<3)+j)<<1], mod_dmrs[(((i<<3)+j)<<1)+1]);
+        printf("DMRS modulation (symbol %d, %d symbols, type %d):\n", l, n_dmrs>>1, dmrs_Type);
+        for (int i=0; i<n_dmrs>>4; i++) {
+          for (int j=0; j<8; j++) {
+            printf("%d %d\t", mod_dmrs[l][((i<<3)+j)<<1], mod_dmrs[l][(((i<<3)+j)<<1)+1]);
+          }
+          printf("\n");
+        }
+#endif
       }
-      printf("\n");
     }
-#endif
-    
-    
+
     /// Resource mapping
     
     // Non interleaved VRB to PRB mapping
@@ -293,30 +312,63 @@ uint8_t nr_generate_pdsch(PHY_VARS_gNB *gNB,
       printf("DMRS Type %d params for ap %d: Wt %d %d \t Wf %d %d \t delta %d \t l_prime %d \t l0 %d\tDMRS symbol %d\n",
 	     1+dmrs_Type,ap, Wt[0], Wt[1], Wf[0], Wf[1], delta, l_prime, l0, dmrs_symbol);
 #endif
-      uint8_t k_prime=0;
-      uint16_t m=0, n=0, dmrs_idx=0, k=0;
-      
+
+      uint16_t m=0, dmrs_idx=0, k=0;
+
       int txdataF_offset = (slot%2)*frame_parms->samples_per_slot_wCP;
 
+      // Loop Over OFDM symbols:
       for (int l=rel15->StartSymbolIndex; l<rel15->StartSymbolIndex+rel15->NrOfSymbols; l++) {
-        k = start_sc;
-        n = 0;
-        k_prime = 0;
-        if (dmrs_Type == NFAPI_NR_DMRS_TYPE1) // another if condition to be included to check pdsch config type (reference of k)
-          dmrs_idx = rel15->rbStart*6;
-        else
-          dmrs_idx = rel15->rbStart*4;
-        for (int i=0; i<rel15->rbSize*NR_NB_SC_PER_RB; i++) {
+        /// DMRS QPSK modulation
+        uint8_t k_prime=0;
+        uint16_t n=0;
+        if ((dmrs_symbol_map & (1 << l))){ //DMRS time occasion
+          if (dmrs_Type == NFAPI_NR_DMRS_TYPE1) // another if condition to be included to check pdsch config type (reference of k)
+            dmrs_idx = rel15->rbStart*6;
+          else
+            dmrs_idx = rel15->rbStart*4;
+        }
 
-          if ((rel15->dlDmrsSymbPos & (1 << l)) && (k == ((start_sc+get_dmrs_freq_idx(n, k_prime, delta, dmrs_Type))%(frame_parms->ofdm_symbol_size)))) {
+        // Update l_prime in the case of double DMRS config
+        if ((dmrs_symbol_map & (1 << l))){ //DMRS time occasion
+          if (l==(l_overline+1)) //take into account the double DMRS symbols
+            l_prime = 1;
+          else if (l>(l_overline+1)) {//new DMRS pair
+            l_overline = l;
+            l_prime = 0;
+          }
+        }
 
-            if (l==(l_overline+1)) //take into account the double DMRS symbols
-              l_prime = 1;
-            else if (l>(l_overline+1)) {//new DMRS pair
-              l_overline = l;
-              l_prime = 0;
-            }
+        /* calculate if current symbol is PTRS symbols */
+        ptrs_idx = 0;
+
+        if(rel15->pduBitmap & 0x1) {
+          ptrs_symbol = is_ptrs_symbol(l,dlPtrsSymPos);
+          if(ptrs_symbol) {
+            /* PTRS QPSK Modulation for each OFDM symbol in a slot */
+            nr_modulation(pdsch_dmrs[l][0], (n_ptrs<<1), DMRS_MOD_ORDER, mod_ptrs);
+          }
+        }
+        k = start_sc;
+        // Loop Over SCs:
+        for (int i=0; i<rel15->rbSize*NR_NB_SC_PER_RB; i++) {
+          /* check if cuurent RE is PTRS RE*/
+          is_ptrs_re=0;
+          /* check for PTRS symbol and set flag for PTRS RE */
+          if(ptrs_symbol){
+            is_ptrs_re = is_ptrs_subcarrier(k,
+                                            rel15->rnti,
+                                            ap,
+                                            rel15->dmrsConfigType,
+                                            rel15->PTRSFreqDensity,
+                                            rel15->rbSize,
+                                            rel15->PTRSReOffset,
+                                            start_sc,
+                                            frame_parms->ofdm_symbol_size);
+          }
 
+          /* Map DMRS Symbol */
+          if ( ( dmrs_symbol_map & (1 << l) ) && (k == ((start_sc+get_dmrs_freq_idx(n, k_prime, delta, dmrs_Type))%(frame_parms->ofdm_symbol_size)))) {
             ((int16_t*)txdataF[ap])[((l*frame_parms->ofdm_symbol_size + k)<<1) + (2*txdataF_offset)] = (Wt[l_prime]*Wf[k_prime]*amp*mod_dmrs[l][dmrs_idx<<1]) >> 15;
             ((int16_t*)txdataF[ap])[((l*frame_parms->ofdm_symbol_size + k)<<1) + 1 + (2*txdataF_offset)] = (Wt[l_prime]*Wf[k_prime]*amp*mod_dmrs[l][(dmrs_idx<<1) + 1]) >> 15;
 #ifdef DEBUG_DLSCH_MAPPING
@@ -328,10 +380,21 @@ uint8_t nr_generate_pdsch(PHY_VARS_gNB *gNB,
             k_prime++;
             k_prime&=1;
             n+=(k_prime)?0:1;
-
-          } else {
-
-            if( (!(rel15->dlDmrsSymbPos & (1 << l))) || allowed_xlsch_re_in_dmrs_symbol(k,start_sc,frame_parms->ofdm_symbol_size,rel15->numDmrsCdmGrpsNoData,dmrs_Type)) {
+          }
+          /* Map PTRS Symbol */
+          else if(is_ptrs_re){
+            ((int16_t*)txdataF[ap])[((l*frame_parms->ofdm_symbol_size + k)<<1) + (2*txdataF_offset)] = (beta_ptrs*amp*mod_ptrs[ptrs_idx<<1]) >> 15;
+            ((int16_t*)txdataF[ap])[((l*frame_parms->ofdm_symbol_size + k)<<1) + 1 + (2*txdataF_offset)] = (beta_ptrs*amp*mod_ptrs[(ptrs_idx<<1) + 1])>> 15;
+#ifdef DEBUG_DLSCH_MAPPING
+            printf("ptrs_idx %d\t l %d \t k %d \t k_prime %d \t n %d \t txdataF: %d %d\n",
+                   ptrs_idx, l, k, k_prime, n, ((int16_t*)txdataF[ap])[((l*frame_parms->ofdm_symbol_size + k)<<1) + (2*txdataF_offset)],
+                   ((int16_t*)txdataF[ap])[((l*frame_parms->ofdm_symbol_size + k)<<1) + 1 + (2*txdataF_offset)]);
+#endif
+            ptrs_idx++;
+          }
+          /* Map DATA Symbol */
+          else {
+            if( (!(dmrs_symbol_map & (1 << l))) || allowed_xlsch_re_in_dmrs_symbol(k,start_sc,frame_parms->ofdm_symbol_size,rel15->numDmrsCdmGrpsNoData,dmrs_Type)) {
               ((int16_t*)txdataF[ap])[((l*frame_parms->ofdm_symbol_size + k)<<1) + (2*txdataF_offset)] = (amp * tx_layers[ap][m<<1]) >> 15;
               ((int16_t*)txdataF[ap])[((l*frame_parms->ofdm_symbol_size + k)<<1) + 1 + (2*txdataF_offset)] = (amp * tx_layers[ap][(m<<1) + 1]) >> 15;
 #ifdef DEBUG_DLSCH_MAPPING

openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c

@@ -328,8 +328,7 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
   uint16_t nb_rb = rel15->rbSize;
   uint8_t nb_symb_sch = rel15->NrOfSymbols;
   uint32_t A, Kb, F=0;
-  static uint32_t Z = 0;
-  uint32_t *Zc = &Z;
+  uint32_t *Zc = &dlsch->harq_processes[harq_pid]->Z;
   uint8_t mod_order = rel15->qamModOrder[0];
   uint16_t Kr=0,r;
   uint32_t r_offset=0;

openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c

@@ -1234,16 +1234,16 @@ int nr_rx_pusch(PHY_VARS_gNB *gNB,
     {
       start_meas(&gNB->ulsch_ptrs_processing_stats);
       nr_pusch_ptrs_processing(gNB,
+                               frame_parms,
                                rel15_ul,
                                ulsch_id,
                                nr_tti_rx,
-                               dmrs_symbol_flag,
                                symbol,
                                nb_re_pusch);
       stop_meas(&gNB->ulsch_ptrs_processing_stats);
 
       /*  Subtract total PTRS RE's in the symbol from PUSCH RE's */
-      gNB->pusch_vars[ulsch_id]->ul_valid_re_per_slot[symbol] -= gNB->pusch_vars[ulsch_id]->ptrs_sc_per_ofdm_symbol;
+      gNB->pusch_vars[ulsch_id]->ul_valid_re_per_slot[symbol] -= gNB->pusch_vars[ulsch_id]->ptrs_re_per_slot;
     }
 
     /*---------------------------------------------------------------------------------------------------- */

openair1/PHY/NR_UE_ESTIMATION/nr_dl_channel_estimation.c

@@ -24,6 +24,9 @@
 #include "SCHED_NR_UE/defs.h"
 #include "nr_estimation.h"
 #include "PHY/NR_REFSIG/refsig_defs_ue.h"
+#include "PHY/NR_REFSIG/nr_refsig.h"
+#include "PHY/NR_REFSIG/dmrs_nr.h"
+#include "PHY/NR_REFSIG/ptrs_nr.h"
 #include "PHY/NR_TRANSPORT/nr_sch_dmrs.h"
 #include "filt16a_32.h"
 
@@ -667,7 +670,7 @@ int nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
   int **dl_ch_estimates  =ue->pdsch_vars[proc->thread_id][eNB_offset]->dl_ch_estimates;
   int **rxdataF=ue->common_vars.common_vars_rx_data_per_thread[proc->thread_id].rxdataF;
 
-  if (ue->high_speed_flag == 0) // use second channel estimate position for temporary storage
+  if (ue->high_speed_flag == 0)
     ch_offset     = ue->frame_parms.ofdm_symbol_size ;
   else
     ch_offset     = ue->frame_parms.ofdm_symbol_size*symbol;
@@ -686,7 +689,7 @@ int nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
   uint16_t rb_offset = (bwp_start_subcarrier - ue->frame_parms.first_carrier_offset) / 12;
   uint8_t config_type = ue->dmrs_DownlinkConfig.pdsch_dmrs_type;
   int8_t delta = get_delta(p, config_type);
-  nr_pdsch_dmrs_rx(ue,Ns,ue->nr_gold_pdsch[eNB_offset][Ns][0], &pilot[0],1000+p,0,nb_rb_pdsch+rb_offset);
+  nr_pdsch_dmrs_rx(ue,Ns,ue->nr_gold_pdsch[eNB_offset][Ns][symbol], &pilot[0],1000,0,nb_rb_pdsch+rb_offset);
 
   if (config_type == pdsch_dmrs_type1){
     nushift = (p>>1)&1;
@@ -1196,3 +1199,168 @@ int nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
   }
   return(0);
 }
+
+/*******************************************************************
+ *
+ * NAME :         nr_pdsch_ptrs_processing
+ *
+ * PARAMETERS :   ue                : ue data structure
+ *                NR_UE_PDSCH       : pdsch_vars pointer
+ *                NR_DL_FRAME_PARMS : frame_parms pointer
+ *                NR_DL_UE_HARQ_t   : dlsch0_harq pointer
+ *                NR_DL_UE_HARQ_t   : dlsch1_harq pointer
+ *                uint8_t           : eNB_id,
+ *                uint8_t           : nr_slot_rx,
+ *                unsigned char     : symbol,
+ *                uint32_t          : nb_re_pdsch,
+ *                unsigned char     : harq_pid
+ *                uint16_t          : rnti
+ *                RX_type_t         : rx_type
+ * RETURN : Nothing
+ *
+ * DESCRIPTION :
+ *  If ptrs is enabled process the symbol accordingly
+ *  1) Estimate common phase error per PTRS symbol
+ *  2) Interpolate PTRS estimated value in TD after all PTRS symbols
+ *  3) Compensate signal with PTRS estimation for slot
+ *********************************************************************/
+void nr_pdsch_ptrs_processing(PHY_VARS_NR_UE *ue,
+                              NR_UE_PDSCH **pdsch_vars,
+                              NR_DL_FRAME_PARMS *frame_parms,
+                              NR_DL_UE_HARQ_t *dlsch0_harq,
+                              NR_DL_UE_HARQ_t *dlsch1_harq,
+                              uint8_t eNB_id,
+                              uint8_t nr_slot_rx,
+                              unsigned char symbol,
+                              uint32_t nb_re_pdsch,
+                              unsigned char harq_pid,
+                              uint16_t rnti,
+                              RX_type_t rx_type)
+{
+  //#define DEBUG_DL_PTRS 1
+  int16_t *phase_per_symbol = NULL;
+  int32_t *ptrs_re_symbol = NULL;
+  int8_t   ret = 0;
+  /* harq specific variables */
+  uint8_t  symbInSlot       = 0;
+  uint16_t *startSymbIndex  = NULL;
+  uint16_t *nbSymb          = NULL;
+  uint8_t  *L_ptrs          = NULL;
+  uint8_t  *K_ptrs          = NULL;
+  uint16_t *dmrsSymbPos     = NULL;
+  uint16_t *ptrsSymbPos     = NULL;
+  uint8_t  *ptrsSymbIdx     = NULL;
+  uint8_t  *ptrsReOffset    = NULL;
+  uint8_t  *dmrsConfigType  = NULL;
+  uint16_t *nb_rb           = NULL;
+
+  if(dlsch0_harq->status == ACTIVE) {
+    symbInSlot      = dlsch0_harq->start_symbol + dlsch0_harq->nb_symbols;
+    startSymbIndex  = &dlsch0_harq->start_symbol;
+    nbSymb          = &dlsch0_harq->nb_symbols;
+    L_ptrs          = &dlsch0_harq->PTRSTimeDensity;
+    K_ptrs          = &dlsch0_harq->PTRSFreqDensity;
+    dmrsSymbPos     = &dlsch0_harq->dlDmrsSymbPos;
+    ptrsSymbPos     = &dlsch0_harq->ptrs_symbols;
+    ptrsSymbIdx     = &dlsch0_harq->ptrs_symbol_index;
+    ptrsReOffset    = &dlsch0_harq->PTRSReOffset;
+    dmrsConfigType  = &dlsch0_harq->ptrs_symbol_index;
+    nb_rb           = &dlsch0_harq->nb_rb;
+  }
+  if(dlsch1_harq) {
+    symbInSlot      = dlsch1_harq->start_symbol + dlsch0_harq->nb_symbols;
+    startSymbIndex  = &dlsch1_harq->start_symbol;
+    nbSymb          = &dlsch1_harq->nb_symbols;
+    L_ptrs          = &dlsch1_harq->PTRSTimeDensity;
+    K_ptrs          = &dlsch1_harq->PTRSFreqDensity;
+    dmrsSymbPos     = &dlsch1_harq->dlDmrsSymbPos;
+    ptrsSymbPos     = &dlsch1_harq->ptrs_symbols;
+    ptrsSymbIdx     = &dlsch1_harq->ptrs_symbol_index;
+    ptrsReOffset    = &dlsch1_harq->PTRSReOffset;
+    dmrsConfigType  = &dlsch1_harq->ptrs_symbol_index;
+    nb_rb           = &dlsch1_harq->nb_rb;
+  }
+  /* loop over antennas */
+  for (int aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+    phase_per_symbol = (int16_t*)pdsch_vars[eNB_id]->ptrs_phase_per_slot[aarx];
+    ptrs_re_symbol = (int32_t*)pdsch_vars[eNB_id]->ptrs_re_per_slot[aarx];
+    ptrs_re_symbol[symbol] = 0;
+    phase_per_symbol[(2*symbol)+1] = 0; // Imag
+    /* set DMRS estimates to 0 angle with magnitude 1 */
+    if(is_dmrs_symbol(symbol,*dmrsSymbPos)) {
+      /* set DMRS real estimation to 32767 */
+      phase_per_symbol[2*symbol]=(int16_t)((1<<15)-1); // 32767
+#ifdef DEBUG_DL_PTRS
+      printf("[PHY][PTRS]: DMRS Symbol %d -> %4d + j*%4d\n", symbol, phase_per_symbol[2*symbol],phase_per_symbol[(2*symbol)+1]);
+#endif
+    }
+    else { // real ptrs value is set to 0
+      phase_per_symbol[2*symbol] = 0; // Real
+    }
+
+    if(dlsch0_harq->status == ACTIVE) {
+      if(symbol == *startSymbIndex) {
+        *ptrsSymbPos = 0;
+        set_ptrs_symb_idx(ptrsSymbPos,
+                          *nbSymb,
+                          *startSymbIndex,
+                          1<< *L_ptrs,
+                          *dmrsSymbPos);
+      }
+      /* if not PTRS symbol set current ptrs symbol index to zero*/
+      *ptrsSymbIdx = 0;
+      /* Check if current symbol contains PTRS */
+      if(is_ptrs_symbol(symbol, *ptrsSymbPos)) {
+        *ptrsSymbIdx = symbol;
+        /*------------------------------------------------------------------------------------------------------- */
+        /* 1) Estimate common phase error per PTRS symbol                                                                */
+        /*------------------------------------------------------------------------------------------------------- */
+        nr_ptrs_cpe_estimation(*K_ptrs,*ptrsReOffset,*dmrsConfigType,*nb_rb,
+                               rnti,
+                               (int16_t *)&pdsch_vars[eNB_id]->dl_ch_ptrs_estimates_ext[aarx][symbol*nb_re_pdsch],
+                               nr_slot_rx,
+                               symbol,frame_parms->ofdm_symbol_size,
+                               (int16_t*)&pdsch_vars[eNB_id]->rxdataF_comp0[aarx][(symbol * nb_re_pdsch)],
+                               ue->nr_gold_pdsch[eNB_id][nr_slot_rx][symbol],
+                               &phase_per_symbol[2* symbol],
+                               &ptrs_re_symbol[symbol]);
+      }
+    }// HARQ 0
+
+    /* For last OFDM symbol at each antenna perform interpolation and compensation for the slot*/
+    if(symbol == (symbInSlot -1)) {
+      /*------------------------------------------------------------------------------------------------------- */
+      /* 2) Interpolate PTRS estimated value in TD */
+      /*------------------------------------------------------------------------------------------------------- */
+      /* If L-PTRS is > 0 then we need interpolation */
+      if(*L_ptrs > 0) {
+        ret = nr_ptrs_process_slot(*dmrsSymbPos, *ptrsSymbPos, phase_per_symbol, *startSymbIndex, *nbSymb);
+        if(ret != 0) {
+          LOG_W(PHY,"[PTRS] Compensation is skipped due to error in PTRS slot processing !!\n");
+        }
+      }
+#ifdef DEBUG_DL_PTRS
+      LOG_M("ptrsEst.m","est",pdsch_vars[eNB_id]->ptrs_phase_per_slot[aarx],frame_parms->symbols_per_slot,1,1 );
+      LOG_M("rxdataF_bf_ptrs_comp.m","bf_ptrs_cmp",
+            &pdsch_vars[eNB_id]->rxdataF_comp0[aarx][(*startSymbIndex) * NR_NB_SC_PER_RB * (*nb_rb) ],
+            (*nb_rb) * NR_NB_SC_PER_RB * (*nbSymb),1,1);
+#endif
+      /*------------------------------------------------------------------------------------------------------- */
+      /* 3) Compensated DMRS based estimated signal with PTRS estimation                                        */
+      /*--------------------------------------------------------------------------------------------------------*/
+      for(uint8_t i = *startSymbIndex; i< symbInSlot ;i++) {
+        /* DMRS Symbol has 0 phase so no need to rotate the respective symbol */
+        /* Skip rotation if the slot processing is wrong */
+        if((!is_dmrs_symbol(i,*dmrsSymbPos)) && (ret == 0)) {
+#ifdef DEBUG_DL_PTRS
+          printf("[PHY][DL][PTRS]: Rotate Symbol %2d with  %d + j* %d\n", i, phase_per_symbol[2* i],phase_per_symbol[(2* i) +1]);
+#endif
+          rotate_cpx_vector((int16_t*)&pdsch_vars[eNB_id]->rxdataF_comp0[aarx][(i * (*nb_rb) * NR_NB_SC_PER_RB)],
+                            &phase_per_symbol[2* i],
+                            (int16_t*)&pdsch_vars[eNB_id]->rxdataF_comp0[aarx][(i * (*nb_rb) * NR_NB_SC_PER_RB)],
+                            ((*nb_rb) * NR_NB_SC_PER_RB), 15);
+        }// if not DMRS Symbol
+      }// symbol loop
+    }// last symbol check
+  }//Antenna loop
+}//main function

openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h

@@ -103,6 +103,18 @@ void phy_adjust_gain_nr(PHY_VARS_NR_UE *ue,
 
 int16_t get_nr_PL(uint8_t Mod_id, uint8_t CC_id, uint8_t gNB_index);
 
+void nr_pdsch_ptrs_processing(PHY_VARS_NR_UE *ue,
+                              NR_UE_PDSCH **pdsch_vars,
+                              NR_DL_FRAME_PARMS *frame_parms,
+                              NR_DL_UE_HARQ_t *dlsch0_harq,
+                              NR_DL_UE_HARQ_t *dlsch1_harq,
+                              uint8_t eNB_id,
+                              uint8_t nr_slot_rx,
+                              unsigned char symbol,
+                              uint32_t nb_re_pdsch,
+                              unsigned char harq_pid,
+                              uint16_t rnti,
+                              RX_type_t rx_type);
 
 float_t get_nr_RSRP(module_id_t Mod_id,uint8_t CC_id,uint8_t gNB_index);
 

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c

@@ -279,7 +279,6 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
     nb_re_dmrs = 4*harq_process->n_dmrs_cdm_groups;
   }
   uint16_t dmrs_length = get_num_dmrs(harq_process->dlDmrsSymbPos);
-  AssertFatal(dmrs_length == 1 || dmrs_length == 2,"Illegal dmrs_length %d\n",dmrs_length);
 
   uint32_t i,j;
 

openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h

@@ -707,7 +707,8 @@ unsigned short nr_dlsch_extract_rbs_single(int **rxdataF,
                                         unsigned short nb_pdsch_rb,
                                         unsigned char nr_slot_rx,
                                         uint32_t high_speed_flag,
-                                        NR_DL_FRAME_PARMS *frame_parms);
+                                        NR_DL_FRAME_PARMS *frame_parms,
+                                        uint16_t dlDmrsSymbPos);
 
 /** \fn dlsch_extract_rbs_dual(int32_t **rxdataF,
     int32_t **dl_ch_estimates,

openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h

@@ -141,6 +141,8 @@ typedef struct {
   uint8_t decode_phich;
   // Encoder BG
   uint8_t BG;
+  // LDPC lifting size
+  uint32_t Z;
 } NR_UL_UE_HARQ_t;
 
 typedef struct {
@@ -316,6 +318,19 @@ typedef struct {
   uint8_t codeword;
   /// HARQ-ACKs
   NR_UE_HARQ_STATUS_t harq_ack;
+  /// PTRS Frequency Density
+  uint8_t PTRSFreqDensity;
+  /// PTRS Time Density
+  uint8_t PTRSTimeDensity;
+  uint8_t PTRSPortIndex ;
+  uint8_t nEpreRatioOfPDSCHToPTRS;
+  uint8_t PTRSReOffset;
+  /// bit mask of PT-RS ofdm symbol indicies
+  uint16_t ptrs_symbols;
+  // PTRS symbol index, to be updated every PTRS symbol within a slot.
+  uint8_t ptrs_symbol_index;
+  /// PDU BITMAP 
+  uint16_t pduBitmap;
 } NR_DL_UE_HARQ_t;
 
 typedef struct {

openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_coding.c

@@ -227,8 +227,7 @@ int nr_ulsch_encoding(NR_UE_ULSCH_t *ulsch,
   NR_UL_UE_HARQ_t *harq_process; 
   uint16_t nb_rb ;
   uint32_t A, F;
-  static uint32_t Z = 0;
-  uint32_t *pz = &Z; 
+  uint32_t *pz; 
   uint8_t mod_order; 
   uint16_t Kr,r;
   uint32_t r_offset;
@@ -249,7 +248,7 @@ int nr_ulsch_encoding(NR_UE_ULSCH_t *ulsch,
   harq_process = ulsch->harq_processes[harq_pid];
   nb_rb = harq_process->pusch_pdu.rb_size;
   A = harq_process->pusch_pdu.pusch_data.tb_size*8;
-  pz = &Z;
+  pz = &harq_process->Z;
   mod_order = nr_get_Qm_ul(harq_process->pusch_pdu.mcs_index, harq_process->pusch_pdu.mcs_table);
   R = nr_get_code_rate_ul(harq_process->pusch_pdu.mcs_index, harq_process->pusch_pdu.mcs_table);
   Kr=0;
@@ -387,12 +386,13 @@ int nr_ulsch_encoding(NR_UE_ULSCH_t *ulsch,
       printf("%d \n",  harq_process->d[0][cnt]);
       }
       printf("\n");*/
-    encoder_implemparams_t impp;
-    impp.n_segments = harq_process->C;
-    impp.tinput     = NULL;
-    impp.tprep      = NULL;
-    impp.tparity    = NULL;
-    impp.toutput    = NULL;
+    encoder_implemparams_t impp = {
+      .n_segments=harq_process->C,
+      .macro_num=0,
+      .tinput  = NULL,
+      .tprep   = NULL,
+      .tparity = NULL,
+      .toutput = NULL};
 
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_LDPC_ENCODER_OPTIM, VCD_FUNCTION_IN);
 

openair1/PHY/defs_gNB.h

@@ -112,6 +112,8 @@ typedef struct {
   uint32_t F;
   /// Encoder BG
   uint8_t BG;
+  /// LDPC lifting size
+  uint32_t Z;
 } NR_DL_gNB_HARQ_t;
 
 typedef struct {
@@ -467,7 +469,7 @@ typedef struct {
   /// bit mask of PT-RS ofdm symbol indicies
   uint16_t ptrs_symbols;
   // PTRS subcarriers per OFDM symbol
-  uint16_t ptrs_sc_per_ofdm_symbol;
+  int32_t ptrs_re_per_slot;
   /// \brief Estimated phase error based upon PTRS on each symbol .
   /// - first index: ? [0..7] Number of Antenna
   /// - second index: ? [0...14] smybol per slot

openair1/PHY/defs_nr_UE.h

@@ -338,6 +338,10 @@ typedef struct {
   /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
   /// - second index: ? [0..168*N_RB_DL[
   int32_t **dl_ch_estimates_ext;
+  /// \brief Downlink channel estimates extracted in PRBS.
+  /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
+  /// - second index: ? [0..168*N_RB_DL[
+  int32_t **dl_ch_ptrs_estimates_ext;
   /// \brief Downlink cross-correlation of MIMO channel estimates (unquantized PMI) extracted in PRBS. For the SIC receiver we need to store the history of this for each harq process and round
   /// - first index: ? [0..7] (hard coded) accessed via \c harq_pid
   /// - second index: ? [0..7] (hard coded) accessed via \c round
@@ -414,6 +418,16 @@ typedef struct {
   uint32_t llr_offset[14];
   // llr length per ofdm symbol
   uint32_t llr_length[14];
+  // llr offset per ofdm symbol
+  uint32_t dl_valid_re[14];
+  /// \brief Estimated phase error based upon PTRS on each symbol .
+  /// - first index: ? [0..7] Number of Antenna
+  /// - second index: ? [0...14] smybol per slot
+  int32_t **ptrs_phase_per_slot;
+  /// \brief Estimated phase error based upon PTRS on each symbol .
+  /// - first index: ? [0..7] Number of Antenna
+  /// - second index: ? [0...14] smybol per slot
+  int32_t **ptrs_re_per_slot;
 } NR_UE_PDSCH;
 
 #define NR_PDCCH_DEFS_NR_UE
@@ -889,7 +903,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][NR_MAX_PDSCH_DMRS_INIT_LENGTH_DWORD];
+  uint32_t nr_gold_pdsch[2][20][14][NR_MAX_PDSCH_DMRS_INIT_LENGTH_DWORD];
 
   /// PDCCH DMRS
   uint32_t nr_gold_pdcch[7][20][3][52];

openair1/SCHED_NR_UE/fapi_nr_ue_l1.c

@@ -108,9 +108,16 @@ int8_t nr_ue_scheduled_response(nr_scheduled_response_t *scheduled_response){
             dlsch0_harq->harq_ack.pucch_resource_indicator = dlsch_config_pdu->pucch_resource_id;
             dlsch0_harq->harq_ack.slot_for_feedback_ack = (slot+dlsch_config_pdu->pdsch_to_harq_feedback_time_ind)%frame_parms.slots_per_frame;
             dlsch0_harq->Nl=1;
-            dlsch0_harq->mcs_table=0;
+            dlsch0_harq->mcs_table=dlsch_config_pdu->mcs_table;
             dlsch0_harq->harq_ack.rx_status = downlink_harq_process(dlsch0_harq, dlsch0->current_harq_pid, dlsch_config_pdu->ndi, dlsch0->rnti_type);
             dlsch0_harq->harq_ack.vDAI_DL = dlsch_config_pdu->dai;
+            /* PTRS */
+            dlsch0_harq->PTRSFreqDensity = dlsch_config_pdu->PTRSFreqDensity;
+            dlsch0_harq->PTRSTimeDensity = dlsch_config_pdu->PTRSTimeDensity;
+            dlsch0_harq->PTRSPortIndex = dlsch_config_pdu->PTRSPortIndex;
+            dlsch0_harq->nEpreRatioOfPDSCHToPTRS = dlsch_config_pdu->nEpreRatioOfPDSCHToPTRS;
+            dlsch0_harq->PTRSReOffset = dlsch_config_pdu->PTRSReOffset;
+            dlsch0_harq->pduBitmap = dlsch_config_pdu->pduBitmap;
             LOG_D(MAC, ">>>> \tdlsch0->g_pucch = %d\tdlsch0_harq.mcs = %d\n", dlsch0->g_pucch, dlsch0_harq->mcs);
 		
           }

openair1/SCHED_NR_UE/phy_procedures_nr_ue.c

@@ -733,8 +733,7 @@ int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, int eNB_
 
     LOG_D(PHY,"[UE %d] PDSCH type %d active in nr_slot_rx %d, harq_pid %d (%d), rb_start %d, nb_rb %d, symbol_start %d, nb_symbols %d, DMRS mask %x\n",ue->Mod_id,pdsch,nr_slot_rx,harq_pid,dlsch0->harq_processes[harq_pid]->status,pdsch_start_rb,pdsch_nb_rb,s0,s1,dlsch0->harq_processes[harq_pid]->dlDmrsSymbPos);
 
-    // do channel estimation for first DMRS only
-    for (m = s0; m < 3; m++) {
+    for (m = s0; m < (s0 +s1); m++) {
       if (((1<<m)&dlsch0->harq_processes[harq_pid]->dlDmrsSymbPos) > 0) {
         for (uint8_t aatx=0; aatx<1; aatx++) {//for MIMO Config: it shall loop over no_layers
           nr_pdsch_channel_estimation(ue,
@@ -752,12 +751,13 @@ int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, int eNB_
           char filename[100];
           for (uint8_t aarx=0; aarx<ue->frame_parms.nb_antennas_rx; aarx++) {
             sprintf(filename,"PDSCH_CHANNEL_frame%d_slot%d_sym%d_port%d_rx%d.m", nr_frame_rx, nr_slot_rx, m, aatx,aarx);
-            int **dl_ch_estimates = ue->pdsch_vars[ue->current_thread_id[nr_slot_rx]][0]->dl_ch_estimates;
+            int **dl_ch_estimates = ue->pdsch_vars[proc->thread_id][eNB_id]->dl_ch_estimates;
             LOG_M(filename,"channel_F",&dl_ch_estimates[aatx*ue->frame_parms.nb_antennas_rx+aarx][ue->frame_parms.ofdm_symbol_size*m],ue->frame_parms.ofdm_symbol_size, 1, 1);
           }
 #endif
         }
-        break;
+        if ( ue->high_speed_flag == 0 ) //for slow speed case only estimate the channel once per slot
+          break;
       }
     }
     for (m = s0; m < (s1 + s0); m++) {
@@ -930,7 +930,7 @@ void nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
   uint8_t is_cw0_active = 0;
   uint8_t is_cw1_active = 0;
   uint8_t dmrs_type, nb_re_dmrs;
-  uint16_t length_dmrs = 1; 
+  uint16_t dmrs_len = get_num_dmrs(dlsch0->harq_processes[dlsch0->current_harq_pid]->dlDmrsSymbPos);
   uint16_t nb_symb_sch = 9;
   nr_downlink_indication_t dl_indication;
   fapi_nr_rx_indication_t rx_ind;
@@ -1016,7 +1016,7 @@ void nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
     dlsch0->harq_processes[harq_pid]->G = nr_get_G(dlsch0->harq_processes[harq_pid]->nb_rb,
                                                    nb_symb_sch,
                                                    nb_re_dmrs,
-                                                   length_dmrs,
+                                                   dmrs_len,
                                                    dlsch0->harq_processes[harq_pid]->Qm,
                                                    dlsch0->harq_processes[harq_pid]->Nl);
 #if UE_TIMING_TRACE
@@ -1099,11 +1099,11 @@ void nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
       if(is_cw1_active)
       {
           // start ldpc decode for CW 1
-          dlsch1->harq_processes[harq_pid]->G = nr_get_G(dlsch1->harq_processes[harq_pid]->nb_rb,
-							 nb_symb_sch,
-							 nb_re_dmrs,
-							 length_dmrs,
-							 dlsch1->harq_processes[harq_pid]->Qm,
+        dlsch1->harq_processes[harq_pid]->G = nr_get_G(dlsch1->harq_processes[harq_pid]->nb_rb,
+                                                       nb_symb_sch,
+                                                       nb_re_dmrs,
+                                                       dmrs_len,
+                                                       dlsch1->harq_processes[harq_pid]->Qm,
 							 dlsch1->harq_processes[harq_pid]->Nl);
 #if UE_TIMING_TRACE
           start_meas(&ue->dlsch_unscrambling_stats);
@@ -1851,7 +1851,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,
       for (int i=0;i<4;i++) if (((1<<i)&dlsch0_harq->dlDmrsSymbPos) > 0) {symb_dmrs=i;break;}
       AssertFatal(symb_dmrs>=0,"no dmrs in 0..3\n");
       LOG_D(PHY,"Initializing dmrs for symb %d DMRS mask %x\n",symb_dmrs,dlsch0_harq->dlDmrsSymbPos);
-      nr_gold_pdsch(ue,symb_dmrs,0, 1);
+      nr_gold_pdsch(ue,0);
     
       for (uint16_t m=start_symb_sch;m<(nb_symb_sch+start_symb_sch) ; m++){
         nr_slot_fep(ue,
@@ -2019,7 +2019,7 @@ start_meas(&ue->generic_stat);
 
   if(nr_slot_rx==5 &&  ue->dlsch[proc->thread_id][gNB_id][0]->harq_processes[ue->dlsch[proc->thread_id][gNB_id][0]->current_harq_pid]->nb_rb > 20){
        //write_output("decoder_llr.m","decllr",dlsch_llr,G,1,0);
-       //write_output("llr.m","llr",  &ue->pdsch_vars[gNB_id]->llr[0][0],(14*nb_rb*12*dlsch1_harq->Qm) - 4*(nb_rb*4*dlsch1_harq->Qm),1,0);
+       //write_output("llr.m","llr",  &ue->pdsch_vars[proc->thread_id][gNB_id]->llr[0][0],(14*nb_rb*12*dlsch1_harq->Qm) - 4*(nb_rb*4*dlsch1_harq->Qm),1,0);
 
        write_output("rxdataF0_current.m"    , "rxdataF0", &ue->common_vars.common_vars_rx_data_per_thread[proc->thread_id].rxdataF[0][0],14*fp->ofdm_symbol_size,1,1);
        //write_output("rxdataF0_previous.m"    , "rxdataF0_prev_sss", &ue->common_vars.common_vars_rx_data_per_thread[next_thread_id].rxdataF[0][0],14*fp->ofdm_symbol_size,1,1);
@@ -2027,10 +2027,10 @@ start_meas(&ue->generic_stat);
        //write_output("rxdataF0_previous.m"    , "rxdataF0_prev", &ue->common_vars.common_vars_rx_data_per_thread[next_thread_id].rxdataF[0][0],14*fp->ofdm_symbol_size,1,1);
 
        write_output("dl_ch_estimates.m", "dl_ch_estimates_sfn5", &ue->common_vars.common_vars_rx_data_per_thread[proc->thread_id].dl_ch_estimates[0][0][0],14*fp->ofdm_symbol_size,1,1);
-       write_output("dl_ch_estimates_ext.m", "dl_ch_estimatesExt_sfn5", &ue->pdsch_vars[proc->thread_id][0]->dl_ch_estimates_ext[0][0],14*fp->N_RB_DL*12,1,1);
-       write_output("rxdataF_comp00.m","rxdataF_comp00",         &ue->pdsch_vars[proc->thread_id][0]->rxdataF_comp0[0][0],14*fp->N_RB_DL*12,1,1);
-       //write_output("magDLFirst.m", "magDLFirst", &phy_vars_ue->pdsch_vars[proc->thread_id][0]->dl_ch_mag0[0][0],14*fp->N_RB_DL*12,1,1);
-       //write_output("magDLSecond.m", "magDLSecond", &phy_vars_ue->pdsch_vars[proc->thread_id][0]->dl_ch_magb0[0][0],14*fp->N_RB_DL*12,1,1);
+       write_output("dl_ch_estimates_ext.m", "dl_ch_estimatesExt_sfn5", &ue->pdsch_vars[proc->thread_id][gNB_id]->dl_ch_estimates_ext[0][0],14*fp->N_RB_DL*12,1,1);
+       write_output("rxdataF_comp00.m","rxdataF_comp00",         &ue->pdsch_vars[proc->thread_id][gNB_id]->rxdataF_comp0[0][0],14*fp->N_RB_DL*12,1,1);
+       //write_output("magDLFirst.m", "magDLFirst", &phy_vars_ue->pdsch_vars[proc->thread_id][gNB_id]->dl_ch_mag0[0][0],14*fp->N_RB_DL*12,1,1);
+       //write_output("magDLSecond.m", "magDLSecond", &phy_vars_ue->pdsch_vars[proc->thread_id][gNB_id]->dl_ch_magb0[0][0],14*fp->N_RB_DL*12,1,1);
 
        AssertFatal (0,"");
   }

openair1/SCHED_NR_UE/pucch_uci_ue_nr.c

@@ -1008,6 +1008,12 @@ boolean_t select_pucch_resource(PHY_VARS_NR_UE *ue, NR_UE_MAC_INST_t *mac, uint8
 
     if (resource_set_found == TRUE) {
       if (pucch_resource_indicator < MAX_PUCCH_RESOURCE_INDICATOR) {
+        // Verify that the value of pucch_resource_indicator is valid
+        if (mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->resourceSetToAddModList->list.array[pucch_resource_set_id]->resourceList.list.count <= pucch_resource_indicator)
+        {
+          LOG_E(PHY, "Value of pucch_resource_indicator is out of bounds! Possibly due to a false DCI. \n");
+          return (FALSE);
+        }
         /* check if resource indexing by pucch_resource_indicator of this set is compatible */
         if ((ready_pucch_resource_id == TRUE) || (mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->resourceSetToAddModList->list.array[pucch_resource_set_id]->resourceList.list.array[pucch_resource_indicator][0] != MAX_NB_OF_PUCCH_RESOURCES)) {
 

openair1/SIMULATION/NR_PHY/prachsim.c

@@ -116,10 +116,10 @@ int main(int argc, char **argv){
   int i, aa, aarx, **txdata, trial, n_frames = 1, prach_start, rx_prach_start; //, ntrials=1;
   int N_RB_UL = 106, delay = 0, NCS_config = 13, rootSequenceIndex = 1, threequarter_fs = 0, mu = 1, fd_occasion = 0, loglvl = OAILOG_INFO, numRA = 0, prachStartSymbol = 0;
   uint8_t snr1set = 0, ue_speed1set = 0, transmission_mode = 1, n_tx = 1, n_rx = 1, awgn_flag = 0, msg1_frequencystart = 0, num_prach_fd_occasions = 1, prach_format=0;
-  uint8_t frame = 1, subframe = 9, slot=19, slot_gNB=19, config_index = 98, prach_sequence_length = 1, restrictedSetConfig = 0, N_dur, N_t_slot, start_symbol;
+  uint8_t frame = 1, slot=19, slot_gNB=19, config_index = 98, prach_sequence_length = 1, restrictedSetConfig = 0, N_dur, N_t_slot, start_symbol;
   uint16_t Nid_cell = 0, preamble_tx = 0, preamble_delay, format, format0, format1;
   uint32_t tx_lev = 10000, prach_errors = 0; //,tx_lev_dB;
-  uint64_t SSB_positions = 0x01, absoluteFrequencyPointA = 640000;
+  uint64_t SSB_positions = 0x01;
   uint16_t RA_sfn_index;
   uint8_t N_RA_slot;
   uint8_t config_period;
@@ -153,7 +153,7 @@ int main(int argc, char **argv){
 
   randominit(0);
 
-  while ((c = getopt (argc, argv, "hHaA:Cc:r:p:g:n:s:S:t:x:y:v:V:z:N:F:d:Z:L:R:E")) != -1) {
+  while ((c = getopt (argc, argv, "hHaA:Cc:r:p:g:m:n:s:S:t:x:y:v:V:z:N:F:d:Z:L:R:E")) != -1) {
     switch (c) {
     case 'a':
       printf("Running AWGN simulation\n");
@@ -243,6 +243,10 @@ int main(int argc, char **argv){
       threequarter_fs=1;
       break;
 
+    case 'm':
+      mu = atoi(optarg);
+      break;
+
     case 'n':
       n_frames = atoi(optarg);
       break;
@@ -370,13 +374,6 @@ int main(int argc, char **argv){
     }
   }
 
-  
-  if (config_index<67)  { prach_sequence_length=0; slot = subframe*2; slot_gNB = 1+(subframe*2); }
-  uint16_t N_ZC;
-  N_ZC = prach_sequence_length == 0 ? 839 : 139;
-
-  printf("Config_index %d, prach_sequence_length %d\n",config_index,prach_sequence_length);
-
   // Configure log
   logInit();
   set_glog(loglvl);
@@ -411,12 +408,20 @@ int main(int argc, char **argv){
   frame_parms->N_RB_UL          = N_RB_UL;
   frame_parms->threequarter_fs  = threequarter_fs;
   frame_parms->frame_type       = TDD;
-  frame_parms->freq_range       = nr_FR1;
+  frame_parms->freq_range       = (mu==1 ? nr_FR1 : nr_FR2);
   frame_parms->numerology_index = mu;
 
   nr_phy_config_request_sim(gNB, N_RB_UL, N_RB_UL, mu, Nid_cell, SSB_positions);
 
-  //nsymb = (frame_parms->Ncp == 0) ? 14 : 12;
+  uint64_t absoluteFrequencyPointA = (mu==1 ? 640000 : 2070833);
+
+  uint8_t subframe = slot/frame_parms->slots_per_subframe;
+  
+  if (config_index<67 && mu==1)  { prach_sequence_length=0; slot = subframe*2; slot_gNB = 1+(subframe*2); }
+  uint16_t N_ZC = prach_sequence_length == 0 ? 839 : 139;
+
+  printf("Config_index %d, prach_sequence_length %d\n",config_index,prach_sequence_length);
+
 
   printf("FFT Size %d, Extended Prefix %d, Samples per subframe %d, Frame type %s, Frequency Range %s\n",
          NUMBER_OF_OFDM_CARRIERS,
@@ -432,7 +437,14 @@ int main(int argc, char **argv){
 
   gNB->gNB_config.carrier_config.num_tx_ant.value = 1;
   gNB->gNB_config.carrier_config.num_rx_ant.value = 1;
-  gNB->gNB_config.tdd_table.tdd_period.value = 6;
+  if (mu==1)
+    gNB->gNB_config.tdd_table.tdd_period.value = 6;
+  else if (mu==3)
+    gNB->gNB_config.tdd_table.tdd_period.value = 3;
+  else {
+    printf("unsupported numerology %d\n",mu);
+    exit(-1);
+  }
 
   gNB->gNB_config.prach_config.num_prach_fd_occasions.value = num_prach_fd_occasions;
   gNB->gNB_config.prach_config.num_prach_fd_occasions_list = (nfapi_nr_num_prach_fd_occasions_t *) malloc(num_prach_fd_occasions*sizeof(nfapi_nr_num_prach_fd_occasions_t));
@@ -752,7 +764,7 @@ int main(int argc, char **argv){
             LOG_M("prachF0.m","prachF0", &gNB->prach_vars.prachF[0], N_ZC, 1, 1);
             LOG_M("rxsig0.m","rxs0", &gNB->common_vars.rxdata[0][subframe*frame_parms->samples_per_subframe], frame_parms->samples_per_subframe, 1, 1);
             LOG_M("ru_rxsig0.m","rxs0", &ru->common.rxdata[0][subframe*frame_parms->samples_per_subframe], frame_parms->samples_per_subframe, 1, 1);
-            LOG_M("rxsigF0.m","rxsF0", gNB->prach_vars.rxsigF[0], N_ZC, 1, 1);
+            LOG_M("ru_rxsigF0.m","rxsF0", ru->prach_rxsigF[0][0], N_ZC, 1, 1);
             LOG_M("prach_preamble.m","prachp", &gNB->X_u[0], N_ZC, 1, 1);
             LOG_M("ue_prach_preamble.m","prachp", &UE->X_u[0], N_ZC, 1, 1);
           #endif

openair1/SIMULATION/NR_PHY/ulsim.c

@@ -56,7 +56,7 @@
 #include "openair2/LAYER2/NR_MAC_UE/mac_proto.h"
 #include "openair2/LAYER2/NR_MAC_gNB/mac_proto.h"
 #include "common/utils/threadPool/thread-pool.h"
-
+#include "PHY/NR_REFSIG/ptrs_nr.h"
 #define inMicroS(a) (((double)(a))/(cpu_freq_GHz*1000.0))
 #include "SIMULATION/LTE_PHY/common_sim.h"
 
@@ -163,8 +163,7 @@ int main(int argc, char **argv)
   FILE *input_fd = NULL;
   SCM_t channel_model = AWGN;  //Rayleigh1_anticorr;
   uint16_t N_RB_DL = 106, N_RB_UL = 106, mu = 1;
-  double tx_gain=1.0;
-  double N0=30;
+
   NB_UE_INST = 1;
 
   //unsigned char frame_type = 0;
@@ -179,7 +178,6 @@ int main(int argc, char **argv)
   int gNB_id = 0;
   int ap;
   int tx_offset;
-  double txlev_float;
   int32_t txlev;
   int start_rb = 0;
   int UE_id =0; // [hna] only works for UE_id = 0 because NUMBER_OF_NR_UE_MAX is set to 1 (phy_init_nr_gNB causes segmentation fault)
@@ -199,6 +197,9 @@ int main(int argc, char **argv)
   int ptrs_arg[2] = {-1,-1};// Invalid values
   /* DMRS TYPE = dmrs_arg[0], Add Pos = dmrs_arg[1] */
   int dmrs_arg[2] = {-1,-1};// Invalid values
+  uint16_t ptrsSymPos = 0;
+  uint16_t ptrsSymbPerSlot = 0;
+  uint16_t ptrsRePerSymb = 0;
 
   UE_nr_rxtx_proc_t UE_proc;
   FILE *scg_fd=NULL;
@@ -217,6 +218,9 @@ int main(int argc, char **argv)
   //logInit();
   randominit(0);
 
+  /* initialize the sin-cos table */
+   InitSinLUT();
+
   while ((c = getopt(argc, argv, "a:b:c:d:ef:g:h:i:j:kl:m:n:p:r:s:y:z:F:G:H:M:N:PR:S:T:U:L:")) != -1) {
     printf("handling optarg %c\n",c);
     switch (c) {
@@ -950,8 +954,6 @@ int main(int argc, char **argv)
       nr_fill_ulsch(gNB,frame,slot,pusch_pdu);
 
       for (int i=0;i<(TBS/8);i++) ulsch_ue[0]->harq_processes[harq_pid]->a[i]=i&0xff;
-      double scale = 1;
-
       if (input_fd == NULL) {
 
 	  // set FAPI parameters for UE, put them in the scheduled response and call
@@ -974,20 +976,16 @@ int main(int argc, char **argv)
 	  
 	  txlev = signal_energy(&UE->common_vars.txdata[0][tx_offset + 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);
-	  
-	  txlev_float = (double)txlev/scale; // output of signal_energy is fixed point representation
-	  
-	  
       }	
       else n_trials = 1;
 
       if (input_fd == NULL ) {
 
-	sigma_dB = N0;
+	sigma_dB = 10 * log10((double)txlev * ((double)frame_parms->ofdm_symbol_size/(12*nb_rb))) - SNR;;
 	sigma    = pow(10,sigma_dB/10);
 
-	tx_gain = sqrt(pow(10.0,.1*(N0+SNR))/txlev_float);
-	if(n_trials==1) printf("txlev_float %f, sigma_dB %f, tx_gain %f tx_offset %d, slot_offset %d\n",10*log10(txlev_float),sigma_dB,tx_gain,tx_offset,slot_offset);
+
+	if(n_trials==1) printf("sigma %f (%f dB), txlev %f (factor %f)\n",sigma,sigma_dB,10*log10((double)txlev),(double)(double)frame_parms->ofdm_symbol_size/(12*nb_rb));
 
 	for (i=0; i<slot_length; i++) {
 	  for (int aa=0; aa<1; aa++) {
@@ -1006,8 +1004,8 @@ int main(int argc, char **argv)
 	}
 	for (i=0; i<slot_length; i++) {
 	  for (ap=0; ap<frame_parms->nb_antennas_rx; ap++) {
-	    ((int16_t*) &gNB->common_vars.rxdata[ap][slot_offset])[(2*i) + (delay*2)]   = (int16_t)((tx_gain*r_re[ap][i])   + (sqrt(sigma/2)*gaussdouble(0.0,1.0))); // convert to fixed point
-	    ((int16_t*) &gNB->common_vars.rxdata[ap][slot_offset])[(2*i)+1 + (delay*2)]   = (int16_t)((tx_gain*r_im[ap][i]) + (sqrt(sigma/2)*gaussdouble(0.0,1.0)));
+	    ((int16_t*) &gNB->common_vars.rxdata[ap][slot_offset])[(2*i) + (delay*2)]   = (int16_t)((r_re[ap][i])   + (sqrt(sigma/2)*gaussdouble(0.0,1.0))); // convert to fixed point
+	    ((int16_t*) &gNB->common_vars.rxdata[ap][slot_offset])[(2*i)+1 + (delay*2)]   = (int16_t)((r_im[ap][i]) + (sqrt(sigma/2)*gaussdouble(0.0,1.0)));
             /* Add phase noise if enabled */
             if (pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_PTRS) {
               phase_noise(ts, &((int16_t*)&gNB->common_vars.rxdata[ap][slot_offset])[(2*i)],
@@ -1018,6 +1016,17 @@ int main(int argc, char **argv)
 
       }
 
+
+      if(pusch_pdu->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_PTRS) {
+        set_ptrs_symb_idx(&ptrsSymPos,
+                          pusch_pdu->nr_of_symbols,
+                          pusch_pdu->start_symbol_index,
+                          1<<ptrs_time_density,
+                          pusch_pdu->ul_dmrs_symb_pos);
+        ptrsSymbPerSlot = get_ptrs_symbols_in_slot(ptrsSymPos, pusch_pdu->start_symbol_index, pusch_pdu->nr_of_symbols);
+        ptrsRePerSymb = ((pusch_pdu->rb_size + ptrs_freq_density - 1)/ptrs_freq_density);
+        printf("[ULSIM] PTRS Symbols in a slot: %2u, RE per Symbol: %3u, RE in a slot %4d\n", ptrsSymbPerSlot,ptrsRePerSymb, ptrsSymbPerSlot*ptrsRePerSymb );
+      }
 	////////////////////////////////////////////////////////////
 	
 	//----------------------------------------------------------
@@ -1082,7 +1091,7 @@ int main(int argc, char **argv)
             }
             /*  2*5*(50/2), for RB = 50,K = 2 for 5 OFDM PTRS symbols */
             available_bits -= 2 * ptrs_symbols * ((nb_rb + ptrs_freq_density - 1) /ptrs_freq_density);
-            printf("After PTRS subtraction available_bits are : %u \n", available_bits);
+            printf("[ULSIM][PTRS] Available bits are: %5u, removed PTRS bits are: %5d \n",available_bits, (ptrsSymbPerSlot * ptrsRePerSymb * 2) );
         }
 
 	for (i = 0; i < available_bits; i++) {

openair1/SIMULATION/TOOLS/phase_noise.c

@@ -29,14 +29,43 @@
 /* linear phase noise model */
 void phase_noise(double ts, int16_t * InRe, int16_t * InIm)
 {
+  static uint64_t i=0;
+  int32_t x=0 ,y=0;
   double fd = 300;//0.01*30000
-  static double i=0;
-  double real, imag,x ,y;
+  int16_t SinValue = 0, CosValue= 0;
+  double IdxDouble = (double)(i*fd * ts * ResolSinCos * 4);
+  int16_t IdxModulo = ((int32_t)(IdxDouble>0 ? IdxDouble+0.5 : IdxDouble-0.5)) % (ResolSinCos*4);
+  IdxModulo = IdxModulo<0 ? IdxModulo+ResolSinCos*4 : IdxModulo;
+
+  if(IdxModulo<2*ResolSinCos) {//< 2 check for 1st and 2nd
+    if(IdxModulo < ResolSinCos) {// 1st Quadrant
+      SinValue = LUTSin[IdxModulo];
+      CosValue = LUTSin[ResolSinCos-IdxModulo];
+    }
+    else {// 2nd Quadrant
+      SinValue = LUTSin[2*ResolSinCos-IdxModulo];
+      CosValue = -LUTSin[IdxModulo-ResolSinCos];
+    }
+  }
+  else {// 3rd and 4th Quadrant
+    if(IdxModulo < 3*ResolSinCos) {// 3rd Quadrant
+      SinValue = -LUTSin[IdxModulo-2*ResolSinCos];
+      CosValue = -LUTSin[3*ResolSinCos-IdxModulo];
+    }
+    else {//4th Quadrant
+      SinValue = -LUTSin[4*ResolSinCos-IdxModulo];
+      CosValue = LUTSin[IdxModulo-3*ResolSinCos];
+    }
+  }
+  x = ( ((int32_t)InRe[0] * CosValue) - ((int32_t)InIm[0] * SinValue ));
+  y = ( ((int32_t)InIm[0] * CosValue) + ((int32_t)InRe[0] * SinValue ));
+  InRe[0]= (int16_t)(x>>14);
+  InIm[0]= (int16_t)(y>>14);
   i++;
-  real = cos(fd * 2 * M_PI * i * ts);
-  imag = sin (fd * 2 * M_PI * i * ts);
-  x = ((real * (double)InRe[0]) - (imag * (double)InIm[0])) ;
-  y= ((real * (double)InIm[0]) + (imag * (double)InRe[0])) ;
-  InRe[0]= (int16_t)(x);
-  InIm[0]= (int16_t)(y);
+}
+/* Initialisation function for SIN table values */
+void InitSinLUT( void ) {
+  for ( int i=0; i<(ResolSinCos+1); i++ ) {
+    LUTSin[i] = sin((double)(M_PI*i)/(2*ResolSinCos)) * (1<<14); //Format: Q14
+  }
 }

openair1/SIMULATION/TOOLS/sim.h

@@ -466,6 +466,10 @@ double N_RB2channel_bandwidth(uint16_t N_RB);
   \param ts Sampling time 
   \param *Re *Im Real and Imag part of the signal
 */
+//look-up table for the sine (cosine) function
+#define ResolSinCos 100
+uint16_t LUTSin[ResolSinCos+1];
+void InitSinLUT( void );
 void phase_noise(double ts, int16_t * InRe, int16_t * InIm);
 
 #include "targets/RT/USER/rfsim.h"

openair2/LAYER2/NR_MAC_COMMON/nr_mac_common.c

@@ -1879,7 +1879,8 @@ void nr_get_tbs_dl(nfapi_nr_dl_tti_pdsch_pdu *pdsch_pdu,
   }
   uint8_t N_sh_symb = pdsch_rel15->NrOfSymbols;
   uint8_t Imcs = pdsch_rel15->mcsIndex[0];
-  uint16_t N_RE_prime = NR_NB_SC_PER_RB*N_sh_symb - N_PRB_DMRS - N_PRB_oh;
+  uint16_t dmrs_length = get_num_dmrs(pdsch_rel15->dlDmrsSymbPos);
+  uint16_t N_RE_prime = NR_NB_SC_PER_RB*N_sh_symb - N_PRB_DMRS*dmrs_length - N_PRB_oh;
   LOG_D(MAC, "N_RE_prime %d for %d symbols %d DMRS per PRB and %d overhead\n", N_RE_prime, N_sh_symb, N_PRB_DMRS, N_PRB_oh);
 
   uint16_t R;
@@ -1896,10 +1897,10 @@ void nr_get_tbs_dl(nfapi_nr_dl_tti_pdsch_pdu *pdsch_pdu,
 
   TBS = nr_compute_tbs(Qm,
                        R,
-		       pdsch_rel15->rbSize,
-		       N_sh_symb,
-		       N_PRB_DMRS, // FIXME // This should be multiplied by the number of dmrs symbols
-		       N_PRB_oh,
+                       pdsch_rel15->rbSize,
+                       N_sh_symb,
+                       N_PRB_DMRS*dmrs_length,
+                       N_PRB_oh,
                        tb_scaling,
 		       pdsch_rel15->nrOfLayers)>>3;
 
@@ -2784,6 +2785,8 @@ int16_t fill_dmrs_mask(NR_PDSCH_Config_t *pdsch_Config,int dmrs_TypeA_Position,i
 	if (NrOfSymbols < 13 && *dmrs_config->dmrs_AdditionalPosition!=NR_DMRS_DownlinkConfig__dmrs_AdditionalPosition_pos0) return(1<<l0 | 1<<8);
 	if (*dmrs_config->dmrs_AdditionalPosition!=NR_DMRS_DownlinkConfig__dmrs_AdditionalPosition_pos0) return(1<<l0);
 	if (*dmrs_config->dmrs_AdditionalPosition!=NR_DMRS_DownlinkConfig__dmrs_AdditionalPosition_pos1) return(1<<l0 | 1<<10);
+        if (*dmrs_config->dmrs_AdditionalPosition==NR_DMRS_DownlinkConfig__dmrs_AdditionalPosition_pos0) return(1<<l0);
+	if (*dmrs_config->dmrs_AdditionalPosition==NR_DMRS_DownlinkConfig__dmrs_AdditionalPosition_pos1) return(1<<l0 | 1<<10);
       }
     }
     else if (pdsch_Config->dmrs_DownlinkForPDSCH_MappingTypeB &&
@@ -2846,3 +2849,72 @@ int binomial(int n, int k) {
   return c;
 }
 
+/* extract PTRS values from RC and validate it based upon 38.214 5.1.6.3 */
+bool set_dl_ptrs_values(NR_PTRS_DownlinkConfig_t *ptrs_config,
+                        uint16_t rbSize,uint8_t mcsIndex, uint8_t mcsTable,
+                        uint8_t *K_ptrs, uint8_t *L_ptrs,
+                        uint8_t *portIndex,uint8_t *nERatio, uint8_t *reOffset,
+                        uint8_t NrOfSymbols)
+{
+  bool valid = true;
+
+  /* as defined in T 38.214 5.1.6.3 */
+  if(rbSize < 3) {
+    valid = false;
+    return valid;
+  }
+  /* Check for Frequency Density values */
+  if(ptrs_config->frequencyDensity->list.count < 2) {
+    /* Default value for K_PTRS = 2 as defined in T 38.214 5.1.6.3 */
+    *K_ptrs = 2;
+  }
+  else {
+    *K_ptrs = get_K_ptrs(*ptrs_config->frequencyDensity->list.array[0],
+                         *ptrs_config->frequencyDensity->list.array[1],
+                         rbSize);
+  }
+  /* Check for time Density values */
+  if(ptrs_config->timeDensity->list.count < 3) {
+    /* Default value for L_PTRS = 1 as defined in T 38.214 5.1.6.3 */
+       *L_ptrs = 1;
+  }
+  else {
+    *L_ptrs = get_L_ptrs(*ptrs_config->timeDensity->list.array[0],
+                         *ptrs_config->timeDensity->list.array[1],
+                         *ptrs_config->timeDensity->list.array[2],
+                         mcsIndex,
+                         mcsTable);
+  }
+  *portIndex =*ptrs_config->epre_Ratio;
+  *nERatio = *ptrs_config->resourceElementOffset;
+  *reOffset  = 0;
+  /* If either or both of the parameters PT-RS time density (LPT-RS) and PT-RS frequency density (KPT-RS), shown in Table
+   * 5.1.6.3-1 and Table 5.1.6.3-2, indicates that 'PT-RS not present', the UE shall assume that PT-RS is not present
+   */
+  if(*K_ptrs ==2  || *K_ptrs ==4 ) {
+    valid = true;
+  }
+  else {
+    valid = false;
+    return valid;
+  }
+  if(*L_ptrs ==0 || *L_ptrs ==1 || *L_ptrs ==2  ) {
+    valid = true;
+  }
+  else {
+    valid = false;
+    return valid;
+  }
+  /* PTRS is not present also :
+   * When the UE is receiving a PDSCH with allocation duration of 4 symbols and if LPT-RS is set to 4, the UE shall assume
+   * PT-RS is not transmitted
+   * When the UE is receiving a PDSCH with allocation duration of 2 symbols as defined in Clause 7.4.1.1.2 of [4, TS
+   * 38.211] and if LPT-RS is set to 2 or 4, the UE shall assume PT-RS is not transmitted.
+   */
+  if((NrOfSymbols == 4 && *L_ptrs ==2) || ((NrOfSymbols == 2 && *L_ptrs > 0))) {
+    valid = false;
+    return valid;
+  }
+  //printf("[MAC] PTRS is set  K= %u L= %u\n", *K_ptrs,1<<*L_ptrs);
+  return valid;
+}

openair2/LAYER2/NR_MAC_COMMON/nr_mac_common.h

@@ -179,4 +179,10 @@ uint8_t get_L_ptrs(uint8_t mcs1, uint8_t mcs2, uint8_t mcs3, uint8_t I_mcs, uint
 uint8_t get_K_ptrs(uint16_t nrb0, uint16_t nrb1, uint16_t N_RB);
 
 int16_t get_N_RA_RB (int delta_f_RA_PRACH,int delta_f_PUSCH);
+
+bool set_dl_ptrs_values(NR_PTRS_DownlinkConfig_t *ptrs_config,
+                        uint16_t rbSize, uint8_t mcsIndex, uint8_t mcsTable,
+                        uint8_t *K_ptrs, uint8_t *L_ptrs,uint8_t *portIndex,
+                        uint8_t *nERatio,uint8_t *reOffset,
+                        uint8_t NrOfSymbols);
 #endif

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler.c

@@ -337,61 +337,6 @@ void nr_schedule_pusch(int Mod_idP,
   }
 }
 
-
-void nr_schedule_pucch(int Mod_idP,
-                       int UE_id,
-                       int nr_ulmix_slots,
-                       frame_t frameP,
-                       sub_frame_t slotP) {
-
-  uint16_t O_csi, O_ack, O_uci;
-  uint8_t O_sr = 0; // no SR in PUCCH implemented for now
-  NR_ServingCellConfigCommon_t *scc = RC.nrmac[Mod_idP]->common_channels->ServingCellConfigCommon;
-  NR_UE_info_t *UE_info = &RC.nrmac[Mod_idP]->UE_info;
-  AssertFatal(UE_info->active[UE_id],"Cannot find UE_id %d is not active\n",UE_id);
-
-  NR_CellGroupConfig_t *secondaryCellGroup = UE_info->secondaryCellGroup[UE_id];
-  int bwp_id=1;
-  NR_BWP_Uplink_t *ubwp=secondaryCellGroup->spCellConfig->spCellConfigDedicated->uplinkConfig->uplinkBWP_ToAddModList->list.array[bwp_id-1];
-  nfapi_nr_ul_tti_request_t *UL_tti_req = &RC.nrmac[Mod_idP]->UL_tti_req[0];
-
-  NR_sched_pucch *curr_pucch;
-
-  for (int k=0; k<nr_ulmix_slots; k++) {
-    for (int l=0; l<2; l++) {
-      curr_pucch = &UE_info->UE_sched_ctrl[UE_id].sched_pucch[k][l];
-      O_ack = curr_pucch->dai_c;
-      O_csi = curr_pucch->csi_bits;
-      O_uci = O_ack + O_csi + O_sr;
-      if ((O_uci>0) && (frameP == curr_pucch->frame) && (slotP == curr_pucch->ul_slot)) {
-        UL_tti_req->SFN = curr_pucch->frame;
-        UL_tti_req->Slot = curr_pucch->ul_slot;
-        UL_tti_req->pdus_list[UL_tti_req->n_pdus].pdu_type = NFAPI_NR_UL_CONFIG_PUCCH_PDU_TYPE;
-        UL_tti_req->pdus_list[UL_tti_req->n_pdus].pdu_size = sizeof(nfapi_nr_pucch_pdu_t);
-        nfapi_nr_pucch_pdu_t  *pucch_pdu = &UL_tti_req->pdus_list[UL_tti_req->n_pdus].pucch_pdu;
-        memset(pucch_pdu,0,sizeof(nfapi_nr_pucch_pdu_t));
-        UL_tti_req->n_pdus+=1;
-
-        LOG_D(MAC,"Scheduling pucch reception for frame %d slot %d with (%d, %d, %d) (SR ACK, CSI) bits\n",
-              frameP,slotP,O_sr,O_ack,curr_pucch->csi_bits);
-
-        nr_configure_pucch(pucch_pdu,
-                           scc,
-                           ubwp,
-                           UE_info->rnti[UE_id],
-                           curr_pucch->resource_indicator,
-                           O_csi,
-                           O_ack,
-                           O_sr);
-
-        memset((void *) &UE_info->UE_sched_ctrl[UE_id].sched_pucch[k][l],
-               0,
-               sizeof(NR_sched_pucch));
-      }
-    }
-  }
-}
-
 bool is_xlsch_in_slot(uint64_t bitmap, sub_frame_t slot) {
   return (bitmap >> slot) & 0x01;
 }

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c

@@ -291,7 +291,7 @@ void handle_nr_ul_harq(uint16_t slot, NR_UE_sched_ctrl_t *sched_ctrl, NR_mac_sta
     }
     return;
   } else
-    LOG_E(MAC,"Incorrect ULSCH HARQ process %d or invalid state %d\n",hrq_id,cur_harq->state);
+    LOG_W(MAC,"Incorrect ULSCH HARQ process %d or invalid state %d (ignore this warning for RA)\n",hrq_id,cur_harq->state);
 }
 
 /*

openair2/LAYER2/NR_MAC_gNB/mac_proto.h

@@ -183,6 +183,9 @@ void nr_schedule_pucch(int Mod_idP,
                        frame_t frameP,
                        sub_frame_t slotP);
 
+void csi_period_offset(NR_CSI_ReportConfig_t *csirep,
+                       int *period, int *offset);
+
 void nr_csi_meas_reporting(int Mod_idP,
                            int UE_id,
                            frame_t frameP,