make explicit return of the clock drift to shift the corresponding number of samples

remove corresponding global variables

openair1/PHY/NR_UE_ESTIMATION/nr_adjust_synch_ue.c

@@ -33,29 +33,22 @@
 // The adjustment is performed once per frame based on the
 // last channel estimate of the receiver
 
-void nr_adjust_synch_ue(NR_DL_FRAME_PARMS *frame_parms,
-                        PHY_VARS_NR_UE *ue,
-                        module_id_t gNB_id,
-                        const int estimateSz,
-                        struct complex16 dl_ch_estimates_time[][estimateSz],
-                        uint8_t frame,
-                        uint8_t subframe,
-                        unsigned char clear,
-                        short coef)
+int nr_adjust_synch_ue(NR_DL_FRAME_PARMS *frame_parms,
+                       PHY_VARS_NR_UE *ue,
+                       module_id_t gNB_id,
+                       const int estimateSz,
+                       struct complex16 dl_ch_estimates_time[][estimateSz],
+                       uint8_t frame,
+                       uint8_t slot,
+                       short coef)
 {
-
-  static int count_max_pos_ok = 0;
-  static int first_time = 1;
   int max_val = 0, max_pos = 0;
-  const int sync_pos = 0;
   uint8_t sync_offset = 0;
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ADJUST_SYNCH, VCD_FUNCTION_IN);
 
   short ncoef = 32767 - coef;
 
-  LOG_D(PHY,"AbsSubframe %d: rx_offset (before) = %d\n",subframe,ue->rx_offset);
-
   // search for maximum position within the cyclic prefix
   for (int i = -frame_parms->nb_prefix_samples/2; i < frame_parms->nb_prefix_samples/2; i++) {
     int temp = 0;
@@ -74,53 +67,32 @@ void nr_adjust_synch_ue(NR_DL_FRAME_PARMS *frame_parms,
   }
 
   // filter position to reduce jitter
-  if (clear == 1)
-    ue->max_pos_fil = max_pos << 15;
-  else
-    ue->max_pos_fil = ((ue->max_pos_fil * coef) >> 15) + (max_pos * ncoef);
+  ue->max_pos_avg = ((ue->max_pos_avg * coef) >> 15) + (max_pos * ncoef);
 
-  // do not filter to have proactive timing adjustment
-  //ue->max_pos_fil = max_pos << 15;
-
-  int diff = (ue->max_pos_fil >> 15) - sync_pos;
+  int diff = ue->max_pos_avg >> 15;
 
   if (frame_parms->freq_range==nr_FR2) 
     sync_offset = 2;
   else
     sync_offset = 0;
 
-  if ( abs(diff) < (SYNCH_HYST+sync_offset) )
-    ue->rx_offset = 0;
-  else
-    ue->rx_offset = diff;
+  int sampleShift = 0;
+  if (abs(diff) > (NR_SYNCH_HYST + sync_offset))
+    sampleShift = diff;
 
-  const int sample_shift = -(ue->rx_offset>>1);
+  const int sample_shift = -(sampleShift / 2);
   // reset IIR filter for next offset calculation
-  ue->max_pos_fil += sample_shift * 32768;
-
-  if(abs(diff)<5)
-    count_max_pos_ok ++;
-  else
-    count_max_pos_ok = 0;
-      
-  //printf("adjust sync count_max_pos_ok = %d\n",count_max_pos_ok);
-
-  if(count_max_pos_ok > 10 && first_time == 1) {
-    first_time = 0;
-    ue->time_sync_cell = 1;
-  }
+  ue->max_pos_avg += sample_shift * 32768;
 
-#ifdef DEBUG_PHY
-  LOG_I(PHY,"AbsSubframe %d: diff = %i, rx_offset (final) = %i : clear = %d, max_pos = %d, max_pos_fil = %d, max_val = %d, sync_pos %d\n",
-        subframe,
+  LOG_D(PHY,
+        "Slot %d: diff = %i, rx_offset (final) = %i : max_pos = %d, max_pos filtered = %ld, max_power = %d\n",
+        slot,
         diff,
-        ue->rx_offset,
-        clear,
+        sampleShift,
         max_pos,
-        ue->max_pos_fil,
-        max_val,
-        sync_pos);
-#endif //DEBUG_PHY
+        ue->max_pos_avg,
+        max_val);
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ADJUST_SYNCH, VCD_FUNCTION_OUT);
+  return sample_shift;
 }

openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h

@@ -30,7 +30,7 @@
  */
 
 /*!\brief Timing drift hysterisis in samples*/
-#define SYNCH_HYST 2
+#define NR_SYNCH_HYST 1
 
 /* A function to perform the channel estimation of DL PRS signal */
 int nr_prs_channel_estimation(uint8_t gNB_id,
@@ -91,15 +91,14 @@ int nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
                                 int rxdataFsize,
                                 c16_t rxdataF[][rxdataFsize]);
 
-void nr_adjust_synch_ue(NR_DL_FRAME_PARMS *frame_parms,
-                        PHY_VARS_NR_UE *ue,
-                        module_id_t gNB_id,
-			int estimateSz,
-			struct complex16 dl_ch_estimates_time [][estimateSz],
-                        uint8_t frame,
-                        uint8_t subframe,
-                        unsigned char clear,
-                        short coef);
+int nr_adjust_synch_ue(NR_DL_FRAME_PARMS *frame_parms,
+                       PHY_VARS_NR_UE *ue,
+                       module_id_t gNB_id,
+                       int estimateSz,
+                       struct complex16 dl_ch_estimates_time[][estimateSz],
+                       uint8_t frame,
+                       uint8_t subframe,
+                       short coef);
 
 void nr_ue_measurements(PHY_VARS_NR_UE *ue,
                         const UE_nr_rxtx_proc_t *proc,

openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h

@@ -287,6 +287,7 @@ int rx_sss(PHY_VARS_NR_UE *phy_vars_ue,int32_t *tot_metric,uint8_t *flip_max,uin
 /*! \brief receiver for the PBCH
   \returns number of tx antennas or -1 if error
 */
+
 int nr_rx_pbch(PHY_VARS_NR_UE *ue,
                const UE_nr_rxtx_proc_t *proc,
                const int estimateSz,
@@ -297,11 +298,6 @@ int nr_rx_pbch(PHY_VARS_NR_UE *ue,
                fapiPbch_t *result,
                c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP]);
 
-int nr_pbch_detection(const UE_nr_rxtx_proc_t *proc,
-                      PHY_VARS_NR_UE *ue,
-                      int pbch_initial_symbol,
-                      c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP]);
-
 #ifndef modOrder
 #define modOrder(I_MCS,I_TBS) ((I_MCS-I_TBS)*2+2) // Find modulation order from I_TBS and I_MCS
 #endif
@@ -323,7 +319,11 @@ int dump_ue_stats(PHY_VARS_NR_UE *phy_vars_ue,
 @param n_frames
   @param sa current running mode
 */
-int nr_initial_sync(const UE_nr_rxtx_proc_t *proc, PHY_VARS_NR_UE *phy_vars_ue, int n_frames, int sa);
+typedef struct {
+  bool cell_notdetected;
+  int rx_offset;
+} nr_initial_sync_t;
+nr_initial_sync_t nr_initial_sync(UE_nr_rxtx_proc_t *proc, PHY_VARS_NR_UE *phy_vars_ue, int n_frames, int sa);
 
 /*!
   \brief This function gets the carrier frequencies either from FP or command-line-set global variables, depending on the

openair1/PHY/defs_nr_UE.h

@@ -485,12 +485,8 @@ typedef struct PHY_VARS_NR_UE_s {
   uint8_t               init_sync_frame;
   /// temporary offset during cell search prior to MIB decoding
   int              ssb_offset;
-  uint16_t         symbol_offset;  /// offset in terms of symbols for detected ssb in sync
-  int              rx_offset;      /// Timing offset
-  int              rx_offset_diff; /// Timing adjustment for ofdm symbol0 on HW USRP
-  int64_t          max_pos_fil;    /// Timing offset IIR filter
-  bool             apply_timing_offset;     /// Do time sync for current frame
-  int              time_sync_cell;
+  uint16_t symbol_offset; /// offset in terms of symbols for detected ssb in sync
+  int64_t max_pos_avg; /// Timing offset IIR filter
 
   /// Timing Advance updates variables
   /// Timing advance update computed from the TA command signalled from gNB
@@ -644,6 +640,7 @@ typedef struct nr_rxtx_thread_data_s {
   int writeBlockSize;
   nr_phy_data_t phy_data;
   int tx_wait_for_dlsch;
+  int rx_offset;
 } nr_rxtx_thread_data_t;
 
 typedef struct LDPCDecode_ue_s {

openair1/SCHED_NR_UE/defs.h

@@ -98,7 +98,7 @@ typedef struct {
 */
 void phy_procedures_nrUE_TX(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, nr_phy_data_tx_t *phy_data);
 
-void pbch_pdcch_processing(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, nr_phy_data_t *phy_data);
+int pbch_pdcch_processing(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, nr_phy_data_t *phy_data);
 
 void pdsch_processing(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, nr_phy_data_t *phy_data);
 

openair1/SCHED_NR_UE/phy_procedures_nr_ue.c

@@ -826,7 +826,7 @@ static bool nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *
   return dec;
 }
 
-void pbch_pdcch_processing(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, nr_phy_data_t *phy_data)
+int pbch_pdcch_processing(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, nr_phy_data_t *phy_data)
 {
   int frame_rx = proc->frame_rx;
   int nr_slot_rx = proc->nr_slot_rx;
@@ -834,6 +834,7 @@ void pbch_pdcch_processing(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, nr
   fapi_nr_config_request_t *cfg = &ue->nrUE_config;
   NR_DL_FRAME_PARMS *fp = &ue->frame_parms;
   NR_UE_PDCCH_CONFIG *phy_pdcch_config = &phy_data->phy_pdcch_config;
+  int sampleShift = 0;
   nr_ue_dlsch_init(phy_data->dlsch, NR_MAX_NB_LAYERS>4 ? 2:1, ue->max_ldpc_iterations);
   
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_RX, VCD_FUNCTION_IN);
@@ -896,17 +897,9 @@ void pbch_pdcch_processing(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, nr
 
             if (ue->no_timing_correction==0 && pbchSuccess == 0) {
               LOG_D(PHY,"start adjust sync slot = %d no timing %d\n", nr_slot_rx, ue->no_timing_correction);
-              nr_adjust_synch_ue(fp,
-                                 ue,
-                                 gNB_id,
-                                 fp->ofdm_symbol_size,
-                                 dl_ch_estimates_time,
-                                 frame_rx,
-                                 nr_slot_rx,
-                                 0,
-                                 16384);
+              sampleShift =
+                  nr_adjust_synch_ue(fp, ue, gNB_id, fp->ofdm_symbol_size, dl_ch_estimates_time, frame_rx, nr_slot_rx, 16384);
             }
-            ue->apply_timing_offset = true;
           }
           LOG_D(PHY, "Doing N0 measurements in %s\n", __FUNCTION__);
           nr_ue_rrc_measurements(ue, proc, rxdataF);
@@ -996,6 +989,7 @@ void pbch_pdcch_processing(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, nr
   LOG_D(PHY,"[UE %d] Frame %d, nr_slot_rx %d: found %d DCIs\n", ue->Mod_id, frame_rx, nr_slot_rx, dci_cnt);
   phy_pdcch_config->nb_search_space = 0;
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SLOT_FEP_PDCCH, VCD_FUNCTION_OUT);
+  return sampleShift;
 }
 
 void pdsch_processing(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, nr_phy_data_t *phy_data)

openair1/SIMULATION/NR_PHY/dlsim.c

@@ -959,7 +959,6 @@ int main(int argc, char **argv)
       //multipath channel
       //multipath_channel(gNB2UE,s_re,s_im,r_re,r_im,frame_length_complex_samples,0);
 
-      UE->rx_offset=0;
       UE_proc.frame_rx = frame;
       UE_proc.nr_slot_rx = slot;
       UE_proc.gNB_id = 0;

openair1/SIMULATION/NR_PHY/pbchsim.c

@@ -766,21 +766,22 @@ int main(int argc, char **argv)
       }
       if (UE->is_synchronized == 0) {
 	UE_nr_rxtx_proc_t proc={0};
-	ret = nr_initial_sync(&proc, UE, 1, 0);
-	printf("nr_initial_sync1 returns %d\n",ret);
-	if (ret<0) n_errors++;
+  nr_initial_sync_t ret = nr_initial_sync(&proc, UE, 1, 0);
+  printf("nr_initial_sync1 returns %d\n", ret.cell_notdetected);
+  if (ret.cell_notdetected)
+    n_errors++;
       }
       else {
         UE_nr_rxtx_proc_t proc={0};
 
-	UE->rx_offset=0;
-	uint8_t ssb_index = 0;
-  const int estimateSz = frame_parms->symbols_per_slot * frame_parms->ofdm_symbol_size;
-  __attribute__((aligned(32))) struct complex16 dl_ch_estimates[frame_parms->nb_antennas_rx][estimateSz];
-  __attribute__((aligned(32))) struct complex16 dl_ch_estimates_time[frame_parms->nb_antennas_rx][frame_parms->ofdm_symbol_size];
-  while (!((SSB_positions >> ssb_index) & 0x01))
-    ssb_index++; // to select the first transmitted ssb
-  UE->symbol_offset = nr_get_ssb_start_symbol(frame_parms, ssb_index);
+        uint8_t ssb_index = 0;
+        const int estimateSz = frame_parms->symbols_per_slot * frame_parms->ofdm_symbol_size;
+        __attribute__((aligned(32))) struct complex16 dl_ch_estimates[frame_parms->nb_antennas_rx][estimateSz];
+        __attribute__((
+            aligned(32))) struct complex16 dl_ch_estimates_time[frame_parms->nb_antennas_rx][frame_parms->ofdm_symbol_size];
+        while (!((SSB_positions >> ssb_index) & 0x01))
+          ssb_index++; // to select the first transmitted ssb
+        UE->symbol_offset = nr_get_ssb_start_symbol(frame_parms, ssb_index);
 
         int ssb_slot = (UE->symbol_offset/14)+(n_hf*(frame_parms->slots_per_frame>>1));
         proc.nr_slot_rx = ssb_slot;