Sidelink SLSS SEARCH Procedure

CMakeLists.txt

@@ -1061,6 +1061,7 @@ set(PHY_SRC_UE
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/sss_nr.c
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/cic_filter_nr.c
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/nr_initial_sync.c
+  ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/nr_initial_sync_sl.c
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/nr_ue_rf_helpers.c
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/nr_pbch.c
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/nr_psbch_rx.c

openair1/PHY/MODULATION/modulation_UE.h

@@ -54,6 +54,12 @@ int nr_slot_fep(PHY_VARS_NR_UE *ue,
                 unsigned char symbol,
                 c16_t rxdataF[][frame_parms->samples_per_slot_wCP],
                 uint32_t linktype);
+int sl_nr_slot_fep(PHY_VARS_NR_UE *ue,
+                UE_nr_rxtx_proc_t *proc,
+                unsigned char symbol,
+                unsigned char Ns,
+                uint32_t sample_offset,
+                c16_t rxdataF[][ue->SL_UE_PHY_PARAMS.sl_frame_params.samples_per_slot_wCP]);
 
 int nr_slot_fep_init_sync(PHY_VARS_NR_UE *ue,
                           UE_nr_rxtx_proc_t *proc,

openair1/PHY/MODULATION/slot_fep_nr.c

@@ -34,6 +34,99 @@
 #define LOG_I(A,B...) printf(A)
 #endif*/
 
+int sl_nr_slot_fep(PHY_VARS_NR_UE *ue,
+                UE_nr_rxtx_proc_t *proc,
+                unsigned char symbol,
+                unsigned char Ns,
+                uint32_t sample_offset,
+                c16_t rxdataF[][ue->SL_UE_PHY_PARAMS.sl_frame_params.samples_per_slot_wCP])
+{
+  NR_DL_FRAME_PARMS *frame_params = &ue->SL_UE_PHY_PARAMS.sl_frame_params;
+  NR_UE_COMMON *common_vars      = &ue->common_vars;
+
+  AssertFatal(symbol < frame_params->symbols_per_slot, "slot_fep: symbol must be between 0 and %d\n", frame_params->symbols_per_slot-1);
+  AssertFatal(Ns < frame_params->slots_per_frame, "slot_fep: Ns must be between 0 and %d\n", frame_params->slots_per_frame-1);
+
+  unsigned int nb_prefix_samples  = frame_params->nb_prefix_samples;
+  unsigned int nb_prefix_samples0 = frame_params->nb_prefix_samples0;
+
+
+  dft_size_idx_t dftsize = get_dft(frame_params->ofdm_symbol_size);
+  // This is for misalignment issues
+  int32_t tmp_dft_in[8192] __attribute__ ((aligned (32)));
+
+  unsigned int rx_offset = frame_params->get_samples_slot_timestamp(Ns,frame_params,0);
+  unsigned int abs_symbol = Ns * frame_params->symbols_per_slot + symbol;
+
+  rx_offset += sample_offset;
+  rx_offset += ue->rx_offset;
+
+  for (int idx_symb = Ns*frame_params->symbols_per_slot; idx_symb <= abs_symbol; idx_symb++)
+    rx_offset += (idx_symb%(0x7<<frame_params->numerology_index)) ? nb_prefix_samples : nb_prefix_samples0;
+  rx_offset += frame_params->ofdm_symbol_size * symbol;
+
+  // use OFDM symbol from within 1/8th of the CP to avoid ISI
+  rx_offset -= (nb_prefix_samples / frame_params->ofdm_offset_divisor);
+
+#ifdef SL_DEBUG_SLOT_FEP
+  //  if (ue->frame <100)
+  LOG_I(PHY, "slot_fep: slot %d, symbol %d, nb_prefix_samples %u, nb_prefix_samples0 %u, rx_offset %u\n",
+         Ns, symbol, nb_prefix_samples, nb_prefix_samples0, rx_offset);
+#endif
+
+  for (unsigned char aa=0; aa<frame_params->nb_antennas_rx; aa++) {
+    memset(&rxdataF[aa][frame_params->ofdm_symbol_size*symbol],0,frame_params->ofdm_symbol_size*sizeof(int32_t));
+
+    int16_t *rxdata_ptr = (int16_t *)&common_vars->rxdata[aa][rx_offset];
+
+    // if input to dft is not 256-bit aligned
+    if ((rx_offset & 7) != 0) {
+      memcpy((void *)&tmp_dft_in[0],
+             (void *)&common_vars->rxdata[aa][rx_offset],
+             frame_params->ofdm_symbol_size * sizeof(int32_t));
+
+      rxdata_ptr = (int16_t *)tmp_dft_in;
+    }
+
+    dft(dftsize,
+        rxdata_ptr,
+        (int16_t *)&rxdataF[aa][frame_params->ofdm_symbol_size*symbol],
+        1);
+
+
+    int symb_offset = (Ns%frame_params->slots_per_subframe)*frame_params->symbols_per_slot;
+    int32_t rot2 = ((uint32_t*)frame_params->symbol_rotation[1])[symbol+symb_offset];
+    ((int16_t*)&rot2)[1]=-((int16_t*)&rot2)[1];
+
+#ifdef SL_DEBUG_SLOT_FEP
+    //  if (ue->frame <100)
+    LOG_I(PHY, "slot_fep: slot %d, symbol %d rx_offset %u, rotation symbol %d %d.%d\n", Ns,symbol, rx_offset,
+	   symbol+symb_offset,((int16_t*)&rot2)[0],((int16_t*)&rot2)[1]);
+#endif
+
+    rotate_cpx_vector((c16_t *)&rxdataF[aa][frame_params->ofdm_symbol_size*symbol],
+		      (c16_t *)&rot2,
+		      (c16_t *)&rxdataF[aa][frame_params->ofdm_symbol_size*symbol],
+		      frame_params->ofdm_symbol_size,
+		      15);
+
+    int16_t *shift_rot = (int16_t *)frame_params->timeshift_symbol_rotation;
+
+    multadd_cpx_vector((int16_t *)&rxdataF[aa][frame_params->ofdm_symbol_size*symbol],
+          shift_rot,
+          (int16_t *)&rxdataF[aa][frame_params->ofdm_symbol_size*symbol],
+          1,
+          frame_params->ofdm_symbol_size,
+          15);
+  }
+
+
+
+  LOG_D(PHY, "SIDELINK RX: Slot FEP: done for symbol:%d\n", symbol);
+
+  return 0;
+}
+
 int nr_slot_fep(PHY_VARS_NR_UE *ue,
                 NR_DL_FRAME_PARMS *frame_parms,
                 UE_nr_rxtx_proc_t *proc,

openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h

@@ -423,6 +423,8 @@ int nr_rx_psbch(PHY_VARS_NR_UE *ue,
 void nr_tx_psbch(PHY_VARS_NR_UE *UE, uint32_t frame_tx, uint32_t slot_tx,
                  sl_nr_tx_config_psbch_pdu_t *psbch_vars,
                  c16_t **txdataF);
+
+int sl_nr_slss_search(PHY_VARS_NR_UE *UE, UE_nr_rxtx_proc_t *proc, int num_frames);
 /**@}*/
 #endif
 

openair1/PHY/defs_nr_common.h

@@ -169,8 +169,6 @@ struct NR_DL_FRAME_PARMS {
   /// Frame type (0 FDD, 1 TDD)
   frame_type_t frame_type;
   uint8_t tdd_config;
-  /// Sidelink Cell ID
-  uint16_t Nid_SL;
   /// Cell ID
   uint16_t Nid_cell;
   /// subcarrier spacing (15,30,60,120)

openair1/PHY/defs_nr_sl_UE.h

@@ -106,6 +106,24 @@ typedef struct SL_NR_UE_INIT_PARAMS {
 
 } SL_NR_UE_INIT_PARAMS_t;
 
+typedef struct SL_NR_SYNC_PARAMS {
+
+  // Indicating start of SSB block in the initial set of samples
+  uint32_t ssb_offset;
+  // Freq Offset calculated
+  int32_t freq_offset;
+
+  uint32_t remaining_frames;
+  uint32_t rx_offset;
+  uint32_t slot_offset;
+  uint16_t N_sl_id2; //id2 determined from PSS during sync ref UE selection
+  uint16_t N_sl_id1; //id2 determined from SSS during sync ref UE selection
+  uint16_t N_sl_id; //ID calculated from ID1 and ID2
+  int32_t  psbch_rsrp; //rsrp of the decoded psbch during sync ref ue selection
+  uint32_t DFN; // DFN calculated after sync ref UE search
+
+} SL_NR_SYNC_PARAMS_t;
+
 typedef struct SL_NR_UE_PSBCH {
 
   // AVG POWER OF PSBCH DMRS in dB/RE
@@ -128,6 +146,8 @@ typedef struct sl_nr_ue_phy_params {
 
   SL_NR_UE_INIT_PARAMS_t init_params;
 
+  SL_NR_SYNC_PARAMS_t sync_params;
+
   // Sidelink PHY PARAMETERS USED FOR PSBCH reception/Txn
   SL_NR_UE_PSBCH_t psbch;
 

openair1/SCHED_NR_UE/defs.h

@@ -206,6 +206,13 @@ void nr_fill_sl_indication(nr_sidelink_indication_t *sl_ind,
                            UE_nr_rxtx_proc_t *proc,
                            PHY_VARS_NR_UE *ue,
                            void *phy_data);
+void nr_fill_sl_rx_indication(sl_nr_rx_indication_t *rx_ind,
+                              uint8_t pdu_type,
+                              PHY_VARS_NR_UE *ue,
+                              uint16_t n_pdus,
+                              UE_nr_rxtx_proc_t *proc,
+                              void *typeSpecific,
+                              uint16_t rx_slss_id);
 
 #endif
 

openair1/SIMULATION/NR_PHY/psbchsim.c

@@ -24,6 +24,7 @@
 #include "SIMULATION/RF/rf.h"
 #include "common/utils/load_module_shlib.h"
 #include "PHY/MODULATION/nr_modulation.h"
+#include "NR_SL-SSB-TimeAllocation-r16.h"
 void exit_function(const char* file, const char* function, const int line, const char* s, const int assert) {
   const char * msg= s==NULL ? "no comment": s;
   printf("Exiting at: %s:%d %s(), %s\n", file, line, function, msg);
@@ -150,8 +151,7 @@ static void configure_NR_UE(PHY_VARS_NR_UE *UE, int mu, int N_RB) {
   }
 }
 
-static void sl_init_frame_parameters(PHY_VARS_NR_UE *UE)
-{
+static void sl_init_frame_parameters(PHY_VARS_NR_UE *UE) {
 
   NR_DL_FRAME_PARMS *nr_fp = &UE->frame_parms;
   NR_DL_FRAME_PARMS *sl_fp = &UE->SL_UE_PHY_PARAMS.sl_frame_params;
@@ -272,7 +272,7 @@ double cpuf;
 int main(int argc, char **argv) {
 
   char c;
-  int test_freqdomain_loopback = 0;
+  int test_freqdomain_loopback = 0,test_slss_search = 0;
   int frame = 5, slot = 10, frame_tx = 0, slot_tx = 0;
   int loglvl = OAILOG_INFO;
   uint16_t slss_id = 336, ssb_offset = 0;
@@ -299,7 +299,7 @@ int main(int argc, char **argv) {
 
   randominit(0);
 
-  while ((c = getopt(argc, argv, "c:hn:o:s:FL:N:R:S:T:")) != -1) {
+  while ((c = getopt(argc, argv, "c:hn:o:s:FIL:N:R:S:T:")) != -1) {
   
     printf("SIDELINK PSBCH SIM: handling optarg %c\n",c);
     switch (c) {
@@ -364,6 +364,11 @@ int main(int argc, char **argv) {
         test_freqdomain_loopback = 1;
         break;
 
+      case 'I':
+        test_slss_search = 1;
+        printf("SIDELINK PSBCH SIM: SLSS search will be tested\n");
+        break;
+
       case 'L':
         loglvl = atoi(optarg);
         break;
@@ -399,6 +404,7 @@ int main(int argc, char **argv) {
         printf("-o ssb offset from PointA - indicates ssb_start subcarrier\n");
         printf("-s: set Sidelink sync id slss_id. ex -s 100\n");
         printf("-F: Run PSBCH frequency domain loopback test of the samples\n");
+        printf("-I: Sidelink SLSS search will be tested.\n");
         printf("-L: Set Log Level.\n");
         printf("-N: Test with Noise. target SNR0 eg -N 10\n");
         printf("-R N_RB_DL\n");
@@ -494,6 +500,7 @@ int main(int argc, char **argv) {
 
   LOG_I(PHY, "Configure UE-RX and sidelink UE-RX.\n");
   configure_NR_UE(UE_RX, mu, N_RB_DL);
+  UE_RX->is_synchronized = (test_slss_search) ? 0 : 1;
   configure_SL_UE(UE_RX, mu, N_RB_DL,ssb_offset, slss_id);
   /*****************************************/
   sl_nr_ue_phy_params_t *sl_uetx = &UE_TX->SL_UE_PHY_PARAMS;
@@ -559,6 +566,8 @@ int main(int argc, char **argv) {
         }
       }
 
+      LOG_M("txData0.m","txd0", UE_TX->common_vars.txData[0],frame_parms->samples_per_frame,1,1);
+
       //AWGN
       sigma2_dB = 20*log10((double)AMP/4)-SNR;
       sigma2 = pow(10,sigma2_dB/10);
@@ -592,12 +601,26 @@ int main(int argc, char **argv) {
           }
         }
 
-      psbch_pscch_processing(UE_RX,&proc,&phy_data_rx);
+      if (UE_RX->is_synchronized == 0) {
+        int ret = -1;
+	      UE_nr_rxtx_proc_t proc={0};
+        //Should not have SLSS id configured. Search should find SLSS id from TX UE
+        UE_RX->SL_UE_PHY_PARAMS.sl_config.sl_sync_source.rx_slss_id = 0xFFFF;
+	      ret = sl_nr_slss_search(UE_RX, &proc, 1);
+	      printf("Sidelink SLSS search returns %d\n",ret);
+	      if (ret!=0) sl_uerx->psbch.rx_errors = 1;
+        else {
+          AssertFatal(UE_RX->SL_UE_PHY_PARAMS.sync_params.N_sl_id == slss_id,
+                        "DETECTED INCORRECT SLSS ID in SEARCH.CHECK id:%d\n", UE_RX->SL_UE_PHY_PARAMS.sync_params.N_sl_id);
+          sl_uerx->psbch.rx_ok = 1;
+        }
+      } else psbch_pscch_processing(UE_RX,&proc,&phy_data_rx);
 
     } //noise trials
 
-    printf("Runs:%d SNR %f: crc ERRORs = %d, OK = %d\n",
-                            n_trials, SNR,sl_uerx->psbch.rx_errors, sl_uerx->psbch.rx_ok);
+    printf("Runs:%d SNR %f: SLSS Search:%d crc ERRORs = %d, OK = %d\n",
+                                      n_trials, SNR, !UE_RX->is_synchronized,
+                                      sl_uerx->psbch.rx_errors, sl_uerx->psbch.rx_ok);
     errors += sl_uerx->psbch.rx_errors;
     sl_uerx->psbch.rx_errors = 0;
     sl_uerx->psbch.rx_ok = 0;
@@ -605,9 +628,9 @@ int main(int argc, char **argv) {
   } // NSR
 
   if (errors == 0)
-    printf("PSBCH test OK\n");
+    LOG_I(PHY,"PSBCH test OK\n");
   else
-    printf("PSBCH test NOT OK\n");
+    LOG_E(PHY,"PSBCH test NOT OK\n");
 
   free_channel_desc_scm(UE2UE);