applying Robert's comments

common/utils/T/T_messages.txt

@@ -114,6 +114,10 @@ ID = GNB_PHY_DL_OUTPUT_SIGNAL
     DESC = gNodeB output data in the freq domain for slots
     GROUP = ALL:PHY:GRAPHIC:HEAVY:GNB
     FORMAT = int,gNB_ID : int,frame : int,slot : int,antenna : buffer,txdata
+ID = GNB_PHY_UL_SRS_TOA_NS
+    DESC = gNB ToA estimate from SRS (in ns)
+    GROUP = ALL:PHY:GNB
+    FORMAT = int,gNB_ID : int,rnti : int,frame : int,subframe : buffer,toa_ns
 
 #MAC logs
 ID = ENB_MAC_UE_DL_SDU

openair1/PHY/NR_ESTIMATION/nr_measurements_gNB.c

@@ -38,17 +38,18 @@
 
 extern openair0_config_t openair0_cfg[MAX_CARDS];
 
-int nr_est_timing_advance_srs(const NR_DL_FRAME_PARMS *frame_parms, 
-                              const int32_t srs_estimated_channel_time[][frame_parms->ofdm_symbol_size]) {
+int nr_est_timing_advance_srs(uint16_t ofdm_symbol_size,
+                              uint8_t N_ap_srs,
+                              const int32_t srs_estimated_channel_time[N_ap_srs][ofdm_symbol_size])
+{
   int timing_advance = 0;
   int max_val = 0;
 
-  for (int i = 0; i < frame_parms->ofdm_symbol_size; i++) {
+  for (int i = 0; i < ofdm_symbol_size; i++) {
     int temp = 0;
-    for (int aa = 0; aa < frame_parms->nb_antennas_rx; aa++) {
-      int Re = ((c16_t*)srs_estimated_channel_time[aa])[i].r;
-      int Im = ((c16_t*)srs_estimated_channel_time[aa])[i].i;
-      temp += (Re*Re/2) + (Im*Im/2);
+    for (int aa = 0; aa < N_ap_srs; aa++) {
+      c16_t s = ((c16_t*)srs_estimated_channel_time[aa])[i];
+      temp += c16amp2(s) / 2;
     }
     if (temp > max_val) {
       timing_advance = i;
@@ -56,12 +57,12 @@ int nr_est_timing_advance_srs(const NR_DL_FRAME_PARMS *frame_parms,
     }
   }
 
-  if (timing_advance > frame_parms->ofdm_symbol_size/2) {
-    timing_advance = timing_advance - frame_parms->ofdm_symbol_size;
+  if (timing_advance > ofdm_symbol_size/2) {
+    timing_advance = timing_advance - ofdm_symbol_size;
   }
 
   // Scale the 16 factor in N_TA calculation in 38.213 section 4.2 according to the used FFT size
-  const uint16_t bw_scaling = frame_parms->ofdm_symbol_size >> 7;
+  const uint16_t bw_scaling = ofdm_symbol_size >> 7;
 
   // do some integer rounding to improve TA accuracy
   int sync_pos_rounded;

openair1/PHY/NR_ESTIMATION/nr_ul_channel_estimation.c

@@ -42,6 +42,82 @@
 
 #define NO_INTERP 1
 #define dBc(x,y) (dB_fixed(((int32_t)(x))*(x) + ((int32_t)(y))*(y)))
+#define NR_SRS_IDFT_OVERSAMP_FACTOR 8
+
+/* Generic function to find the peak of channel estimation buffer */
+int nr_est_toa_ns_srs(NR_DL_FRAME_PARMS *frame_parms,
+                      uint8_t N_arx,
+                      uint8_t N_ap,
+                      uint8_t N_symb_srs,
+                      int32_t srs_estimated_channel_freq[N_arx][N_ap][frame_parms->ofdm_symbol_size * N_symb_srs],
+                      int16_t *srs_toa_ns)
+{
+  int32_t chF_interpol[N_ap][NR_SRS_IDFT_OVERSAMP_FACTOR * frame_parms->ofdm_symbol_size] __attribute__((aligned(32)));
+  int32_t chT_interpol[N_ap][NR_SRS_IDFT_OVERSAMP_FACTOR * frame_parms->ofdm_symbol_size] __attribute__((aligned(32)));
+  int32_t chT_interpol_mag_squ_avg[NR_SRS_IDFT_OVERSAMP_FACTOR * frame_parms->ofdm_symbol_size] __attribute__((aligned(32)));
+  memset(chF_interpol, 0, sizeof(chF_interpol));
+  memset(chT_interpol, 0, sizeof(chT_interpol));
+
+  int32_t max_val = 0, max_idx = 0, abs_val = 0, mean_val = 0;
+
+  int16_t start_offset = NR_SRS_IDFT_OVERSAMP_FACTOR * frame_parms->ofdm_symbol_size - (frame_parms->ofdm_symbol_size >> 1);
+
+  for (int arx_index = 0; arx_index < N_arx; arx_index++) {
+    memset(chT_interpol_mag_squ_avg, 0, sizeof(chT_interpol_mag_squ_avg));
+
+    for (int symb = 0; symb < N_symb_srs; symb++) {
+      for (int ap_index = 0; ap_index < N_ap; ap_index++) {
+        // Place SRS channel estimates in FFT shifted format for oversampling
+        memcpy((int16_t *)&chF_interpol[ap_index][0],
+               &srs_estimated_channel_freq[arx_index][ap_index][symb * frame_parms->ofdm_symbol_size],
+               (frame_parms->ofdm_symbol_size >> 1) * sizeof(int32_t));
+        memcpy((int16_t *)&chF_interpol[ap_index][start_offset],
+               &srs_estimated_channel_freq[arx_index][ap_index]
+                                          [symb * frame_parms->ofdm_symbol_size + (frame_parms->ofdm_symbol_size >> 1)],
+               (frame_parms->ofdm_symbol_size >> 1) * sizeof(int32_t));
+
+        // Convert to time domain oversampled
+        freq2time(frame_parms->ofdm_symbol_size * NR_SRS_IDFT_OVERSAMP_FACTOR,
+                  (int16_t *)chF_interpol[ap_index],
+                  (int16_t *)chT_interpol[ap_index]);
+
+        for (int k = 0; k < NR_SRS_IDFT_OVERSAMP_FACTOR * frame_parms->ofdm_symbol_size; k++) {
+          chT_interpol_mag_squ_avg[k] += squaredMod(((c16_t *)chT_interpol[ap_index])[k]);
+
+        } // Loop over samples
+      } // antenna port loop
+    } // SRS OFDM symbol loop
+
+    // average over SRS symbols
+    for (int k = 0; k < NR_SRS_IDFT_OVERSAMP_FACTOR * frame_parms->ofdm_symbol_size; k++) {
+      chT_interpol_mag_squ_avg[k] /= N_symb_srs;
+    }
+
+    max_val = 0, max_idx = 0, mean_val = 0;
+    for (int k = 0; k < NR_SRS_IDFT_OVERSAMP_FACTOR * frame_parms->ofdm_symbol_size; k++) {
+      abs_val = chT_interpol_mag_squ_avg[k];
+      mean_val += (abs_val - mean_val) / (k + 1);
+      if (abs_val > max_val) {
+        max_val = abs_val;
+        max_idx = k;
+      }
+    }
+
+    if (max_idx > NR_SRS_IDFT_OVERSAMP_FACTOR * frame_parms->ofdm_symbol_size >> 1)
+      max_idx = max_idx - NR_SRS_IDFT_OVERSAMP_FACTOR * frame_parms->ofdm_symbol_size;
+
+    // Check for detection threshold
+
+    if ((mean_val != 0) && (max_val / mean_val > 100)) {
+      srs_toa_ns[arx_index] = (max_idx * 1e9) / (NR_SRS_IDFT_OVERSAMP_FACTOR * frame_parms->samples_per_frame * 100);
+    } else {
+      srs_toa_ns[arx_index] = 0xFFFF;
+    }
+    LOG_D(PHY, "SRS estimatd ToA [RX ant %d]: %d ns (max_val %d, mean_val %d, max_idx %d)\n", arx_index, srs_toa_ns[arx_index], max_val, mean_val, max_idx);
+  } // Antenna loop
+
+  return 0;
+}
 
 __attribute__((always_inline)) inline c16_t c32x16cumulVectVectWithSteps(c16_t *in1,
                                                                          int *offset1,
@@ -679,116 +755,127 @@ int nr_srs_channel_estimation(
       LOG_I(NR_PHY,"====================== UE port %d --> gNB Rx antenna %i ======================\n", p_index, ant);
 #endif
 
-      uint16_t subcarrier = subcarrier_offset + nr_srs_info->k_0_p[p_index][0];
-      if (subcarrier>frame_parms->ofdm_symbol_size) {
-        subcarrier -= frame_parms->ofdm_symbol_size;
-      }
+      // Estimate the SRS channel over all OFDM symbols
+      for (int srs_symb = 0; srs_symb < (1 << srs_pdu->num_symbols); srs_symb++) {
+        uint16_t srs_symbol_offset = srs_symb * frame_parms->ofdm_symbol_size;
+        uint16_t subcarrier = subcarrier_offset + nr_srs_info->k_0_p[p_index][srs_symb];
+        if (subcarrier > frame_parms->ofdm_symbol_size) {
+          subcarrier -= frame_parms->ofdm_symbol_size;
+        }
 
-      int16_t *srs_estimated_channel16 = (int16_t *)&srs_est[subcarrier + mem_offset];
+        int16_t *srs_estimated_channel16 = (int16_t *)&srs_est[subcarrier + srs_symbol_offset + mem_offset];
 
-      for (int k = 0; k < M_sc_b_SRS; k++) {
+        for (int k = 0; k < M_sc_b_SRS; k++) {
+          if (k % fd_cdm == 0) {
+            ls_estimated[0] = 0;
+            ls_estimated[1] = 0;
+            uint16_t subcarrier_cdm = subcarrier;
 
-        if (k%fd_cdm==0) {
+            for (int cdm_idx = 0; cdm_idx < fd_cdm; cdm_idx++) {
+              int16_t generated_real = srs_generated_signal[p_index][subcarrier_cdm + srs_symbol_offset].r;
+              int16_t generated_imag = srs_generated_signal[p_index][subcarrier_cdm + srs_symbol_offset].i;
 
-          ls_estimated[0] = 0;
-          ls_estimated[1] = 0;
-          uint16_t subcarrier_cdm = subcarrier;
+              int16_t received_real = ((c16_t *)srs_received_signal[ant])[subcarrier_cdm + srs_symbol_offset].r;
+              int16_t received_imag = ((c16_t *)srs_received_signal[ant])[subcarrier_cdm + srs_symbol_offset].i;
 
-          for (int cdm_idx = 0; cdm_idx < fd_cdm; cdm_idx++) {
-            int16_t generated_real = srs_generated_signal[p_index][subcarrier_cdm].r;
-            int16_t generated_imag = srs_generated_signal[p_index][subcarrier_cdm].i;
+              // We know that nr_srs_info->srs_generated_signal_bits bits are enough to represent the generated_real and
+              // generated_imag. So we only need a nr_srs_info->srs_generated_signal_bits shift to ensure that the result fits into
+              // 16 bits.
+              ls_estimated[0] += (int16_t)(((int32_t)generated_real * received_real + (int32_t)generated_imag * received_imag)
+                                           >> nr_srs_info->srs_generated_signal_bits);
+              ls_estimated[1] += (int16_t)(((int32_t)generated_real * received_imag - (int32_t)generated_imag * received_real)
+                                           >> nr_srs_info->srs_generated_signal_bits);
 
-            int16_t received_real = ((c16_t*)srs_received_signal[ant])[subcarrier_cdm].r;
-            int16_t received_imag = ((c16_t*)srs_received_signal[ant])[subcarrier_cdm].i;
-
-            // We know that nr_srs_info->srs_generated_signal_bits bits are enough to represent the generated_real and generated_imag.
-            // So we only need a nr_srs_info->srs_generated_signal_bits shift to ensure that the result fits into 16 bits.
-            ls_estimated[0] += (int16_t)(((int32_t)generated_real*received_real + (int32_t)generated_imag*received_imag)>>nr_srs_info->srs_generated_signal_bits);
-            ls_estimated[1] += (int16_t)(((int32_t)generated_real*received_imag - (int32_t)generated_imag*received_real)>>nr_srs_info->srs_generated_signal_bits);
-
-            // Subcarrier increment
-            subcarrier_cdm += K_TC;
-            if (subcarrier_cdm >= frame_parms->ofdm_symbol_size) {
-              subcarrier_cdm=subcarrier_cdm-frame_parms->ofdm_symbol_size;
+              // Subcarrier increment
+              subcarrier_cdm += K_TC;
+              if (subcarrier_cdm >= frame_parms->ofdm_symbol_size) {
+                subcarrier_cdm = subcarrier_cdm - frame_parms->ofdm_symbol_size;
+              }
             }
           }
-        }
 
-        srs_ls_estimated_channel[subcarrier].r = ls_estimated[0];
-        srs_ls_estimated_channel[subcarrier].i = ls_estimated[1];
+          srs_ls_estimated_channel[subcarrier + srs_symbol_offset].r = ls_estimated[0];
+          srs_ls_estimated_channel[subcarrier + srs_symbol_offset].i = ls_estimated[1];
 
 #ifdef SRS_DEBUG
-        int subcarrier_log = subcarrier-subcarrier_offset;
-        if(subcarrier_log < 0) {
-          subcarrier_log = subcarrier_log + frame_parms->ofdm_symbol_size;
-        }
-        if(subcarrier_log%12 == 0) {
-          LOG_I(NR_PHY,"------------------------------------ %d ------------------------------------\n", subcarrier_log/12);
-          LOG_I(NR_PHY,"\t  __genRe________genIm__|____rxRe_________rxIm__|____lsRe________lsIm_\n");
-        }
-        LOG_I(NR_PHY,"(%4i) %6i\t%6i  |  %6i\t%6i  |  %6i\t%6i\n",
-              subcarrier_log,
-              ((c16_t*)srs_generated_signal[p_index])[subcarrier].r, ((c16_t*)srs_generated_signal[p_index])[subcarrier].i,
-              ((c16_t*)srs_received_signal[ant])[subcarrier].r, ((c16_t*)srs_received_signal[ant])[subcarrier].i,
-              ls_estimated[0], ls_estimated[1]);
+          int subcarrier_log = subcarrier - subcarrier_offset;
+          if (subcarrier_log < 0) {
+            subcarrier_log = subcarrier_log + frame_parms->ofdm_symbol_size;
+          }
+          if (subcarrier_log % 12 == 0) {
+            LOG_I(NR_PHY, "------------------------------------ %d ------------------------------------\n", subcarrier_log / 12);
+            LOG_I(NR_PHY, "\t  __genRe________genIm__|____rxRe_________rxIm__|____lsRe________lsIm_\n");
+          }
+          LOG_I(NR_PHY,
+                "(%4i) %6i\t%6i  |  %6i\t%6i  |  %6i\t%6i\n",
+                subcarrier_log,
+                ((c16_t *)srs_generated_signal[p_index])[subcarrier].r,
+                ((c16_t *)srs_generated_signal[p_index])[subcarrier].i,
+                ((c16_t *)srs_received_signal[ant])[subcarrier].r,
+                ((c16_t *)srs_received_signal[ant])[subcarrier].i,
+                ls_estimated[0],
+                ls_estimated[1]);
 #endif
 
-        const uint16_t sc_offset = subcarrier + mem_offset;
+          const uint16_t sc_offset = subcarrier + mem_offset;
 
-        // Channel interpolation
-        if(srs_pdu->comb_size == 0) {
-          if(k == 0) { // First subcarrier case
-            // filt8_start is {12288,8192,4096,0,0,0,0,0}
-            multadd_real_vector_complex_scalar(filt8_start, ls_estimated, srs_estimated_channel16, 8);
-          } else if(subcarrier < K_TC) { // Start of OFDM symbol case
-            // filt8_start is {12288,8192,4096,0,0,0,0,0}
-            srs_estimated_channel16 = (int16_t *)&srs_est[subcarrier];
-            const short *filter = mem_offset == 0 ? filt8_start : filt8_start_shift2;
-            multadd_real_vector_complex_scalar(filter, ls_estimated, srs_estimated_channel16, 8);
-          } else if((subcarrier+K_TC)>=frame_parms->ofdm_symbol_size || k == (M_sc_b_SRS-1)) { // End of OFDM symbol or last subcarrier cases
-            // filt8_end is {4096,8192,12288,16384,0,0,0,0}
-            const short *filter = mem_offset == 0 || k == (M_sc_b_SRS - 1) ? filt8_end : filt8_end_shift2;
-            multadd_real_vector_complex_scalar(filter, ls_estimated, srs_estimated_channel16, 8);
-          } else if(k%2 == 1) { // 1st middle case
-            // filt8_middle2 is {4096,8192,8192,8192,4096,0,0,0}
-            multadd_real_vector_complex_scalar(filt8_middle2, ls_estimated, srs_estimated_channel16, 8);
-          } else if(k%2 == 0) { // 2nd middle case
-            // filt8_middle4 is {0,0,4096,8192,8192,8192,4096,0}
-            multadd_real_vector_complex_scalar(filt8_middle4, ls_estimated, srs_estimated_channel16, 8);
-            srs_estimated_channel16 = (int16_t *)&srs_est[sc_offset];
+          // Channel interpolation
+          if (srs_pdu->comb_size == 0) {
+            if (k == 0) { // First subcarrier case
+              // filt8_start is {12288,8192,4096,0,0,0,0,0}
+              multadd_real_vector_complex_scalar(filt8_start, ls_estimated, srs_estimated_channel16, 8);
+            } else if (subcarrier < K_TC) { // Start of OFDM symbol case
+              // filt8_start is {12288,8192,4096,0,0,0,0,0}
+              srs_estimated_channel16 = (int16_t *)&srs_est[subcarrier + srs_symbol_offset];
+              const short *filter = mem_offset == 0 ? filt8_start : filt8_start_shift2;
+              multadd_real_vector_complex_scalar(filter, ls_estimated, srs_estimated_channel16, 8);
+            } else if ((subcarrier + K_TC) >= frame_parms->ofdm_symbol_size
+                       || k == (M_sc_b_SRS - 1)) { // End of OFDM symbol or last subcarrier cases
+              // filt8_end is {4096,8192,12288,16384,0,0,0,0}
+              const short *filter = mem_offset == 0 || k == (M_sc_b_SRS - 1) ? filt8_end : filt8_end_shift2;
+              multadd_real_vector_complex_scalar(filter, ls_estimated, srs_estimated_channel16, 8);
+            } else if (k % 2 == 1) { // 1st middle case
+              // filt8_middle2 is {4096,8192,8192,8192,4096,0,0,0}
+              multadd_real_vector_complex_scalar(filt8_middle2, ls_estimated, srs_estimated_channel16, 8);
+            } else if (k % 2 == 0) { // 2nd middle case
+              // filt8_middle4 is {0,0,4096,8192,8192,8192,4096,0}
+              multadd_real_vector_complex_scalar(filt8_middle4, ls_estimated, srs_estimated_channel16, 8);
+              srs_estimated_channel16 = (int16_t *)&srs_est[sc_offset + srs_symbol_offset];
+            }
+          } else {
+            if (k == 0) { // First subcarrier case
+              // filt16_start is {12288,8192,8192,8192,4096,0,0,0,0,0,0,0,0,0,0,0}
+              multadd_real_vector_complex_scalar(filt16_start, ls_estimated, srs_estimated_channel16, 16);
+            } else if (subcarrier < K_TC) { // Start of OFDM symbol case
+              srs_estimated_channel16 = (int16_t *)&srs_est[sc_offset + srs_symbol_offset];
+              // filt16_start is {12288,8192,8192,8192,4096,0,0,0,0,0,0,0,0,0,0,0}
+              multadd_real_vector_complex_scalar(filt16_start, ls_estimated, srs_estimated_channel16, 16);
+            } else if ((subcarrier + K_TC) >= frame_parms->ofdm_symbol_size
+                       || k == (M_sc_b_SRS - 1)) { // End of OFDM symbol or last subcarrier cases
+              // filt16_end is {4096,8192,8192,8192,12288,16384,16384,16384,0,0,0,0,0,0,0,0}
+              multadd_real_vector_complex_scalar(filt16_end, ls_estimated, srs_estimated_channel16, 16);
+            } else { // Middle case
+              // filt16_middle4 is {4096,8192,8192,8192,8192,8192,8192,8192,4096,0,0,0,0,0,0,0}
+              multadd_real_vector_complex_scalar(filt16_middle4, ls_estimated, srs_estimated_channel16, 16);
+              srs_estimated_channel16 = (int16_t *)&srs_est[sc_offset + srs_symbol_offset];
+            }
           }
-        } else {
-          if(k == 0) { // First subcarrier case
-            // filt16_start is {12288,8192,8192,8192,4096,0,0,0,0,0,0,0,0,0,0,0}
-            multadd_real_vector_complex_scalar(filt16_start, ls_estimated, srs_estimated_channel16, 16);
-          } else if(subcarrier < K_TC) { // Start of OFDM symbol case
-            srs_estimated_channel16 = (int16_t *)&srs_est[sc_offset];
-            // filt16_start is {12288,8192,8192,8192,4096,0,0,0,0,0,0,0,0,0,0,0}
-            multadd_real_vector_complex_scalar(filt16_start, ls_estimated, srs_estimated_channel16, 16);
-          } else if((subcarrier+K_TC)>=frame_parms->ofdm_symbol_size || k == (M_sc_b_SRS-1)) { // End of OFDM symbol or last subcarrier cases
-            // filt16_end is {4096,8192,8192,8192,12288,16384,16384,16384,0,0,0,0,0,0,0,0}
-            multadd_real_vector_complex_scalar(filt16_end, ls_estimated, srs_estimated_channel16, 16);
-          } else { // Middle case
-            // filt16_middle4 is {4096,8192,8192,8192,8192,8192,8192,8192,4096,0,0,0,0,0,0,0}
-            multadd_real_vector_complex_scalar(filt16_middle4, ls_estimated, srs_estimated_channel16, 16);
-            srs_estimated_channel16 = (int16_t *)&srs_est[sc_offset];
+
+          // Subcarrier increment
+          subcarrier += K_TC;
+          if (subcarrier >= frame_parms->ofdm_symbol_size) {
+            subcarrier = subcarrier - frame_parms->ofdm_symbol_size;
           }
-        }
 
-        // Subcarrier increment
-        subcarrier += K_TC;
-        if (subcarrier >= frame_parms->ofdm_symbol_size) {
-          subcarrier=subcarrier-frame_parms->ofdm_symbol_size;
-        }
-
-      } // for (int k = 0; k < M_sc_b_SRS; k++)
+        } // for (int k = 0; k < M_sc_b_SRS; k++)
+      } // for (int srs_symb = 0; srs_symb<(1<<srs_pdu->num_symbols); srs_symb++)
 
       memcpy(&srs_estimated_channel_freq[ant][p_index][0],
              &srs_est[mem_offset],
-             (frame_parms->ofdm_symbol_size*(1<<srs_pdu->num_symbols))*sizeof(int32_t));
+             ((1 << srs_pdu->num_symbols) * (frame_parms->ofdm_symbol_size)) * sizeof(int32_t));
 
       // Compute noise
-      subcarrier = subcarrier_offset + nr_srs_info->k_0_p[p_index][0];
+      uint16_t subcarrier = subcarrier_offset + nr_srs_info->k_0_p[p_index][0];
       if (subcarrier>frame_parms->ofdm_symbol_size) {
         subcarrier -= frame_parms->ofdm_symbol_size;
       }
@@ -804,6 +891,13 @@ int nr_srs_channel_estimation(
         }
       }
 
+#ifdef SRS_DEBUG
+      // Compute signal power
+      uint32_t signal_power_ant = calc_power(&ch_real[base_idx], M_sc_b_SRS) + calc_power(&ch_imag[base_idx], M_sc_b_SRS);
+
+      LOG_I(NR_PHY, "signal_power(p_index %d, ant %d) = %d dB\n", p_index, ant, dB_fixed(signal_power_ant));
+#endif
+
 #ifdef SRS_DEBUG
       subcarrier = subcarrier_offset + nr_srs_info->k_0_p[p_index][0];
       if (subcarrier>frame_parms->ofdm_symbol_size) {
@@ -850,7 +944,6 @@ int nr_srs_channel_estimation(
       memcpy(&srs_estimated_channel_time_shifted[ant][p_index][gNB->frame_parms.ofdm_symbol_size>>1],
              &srs_estimated_channel_time[ant][p_index][0],
              (gNB->frame_parms.ofdm_symbol_size>>1)*sizeof(int32_t));
-
     } // for (int p_index = 0; p_index < N_ap; p_index++)
   } // for (int ant = 0; ant < frame_parms->nb_antennas_rx; ant++)
 
@@ -858,7 +951,7 @@ int nr_srs_channel_estimation(
   uint32_t signal_power = calc_power(ch_real, arr_len) + calc_power(ch_imag, arr_len);
 
 #ifdef SRS_DEBUG
-  LOG_I(NR_PHY,"signal_power = %u\n", signal_power);
+  LOG_I(NR_PHY, "signal_power = %d dB\n", dB_fixed(signal_power));
 #endif
 
   if (signal_power == 0) {
@@ -867,7 +960,6 @@ int nr_srs_channel_estimation(
   }
 
   // Compute noise power
-
   const uint8_t signal_power_bits = log2_approx(signal_power);
   const uint8_t factor_bits = signal_power_bits < 32 ? 32 - signal_power_bits : 0; // 32 due to input of dB_fixed(uint32_t x)
   const int32_t factor_dB = dB_fixed(1<<factor_bits);

openair1/PHY/NR_ESTIMATION/nr_ul_estimation.h

@@ -62,8 +62,16 @@ void nr_gnb_measurements(PHY_VARS_gNB *gNB,
                          unsigned char symbol,
                          uint8_t nrOfLayers);
 
-int nr_est_timing_advance_srs(const NR_DL_FRAME_PARMS *frame_parms,
-                              const int32_t srs_estimated_channel_time[][frame_parms->ofdm_symbol_size]);
+int nr_est_timing_advance_srs(uint16_t ofdm_symbol_size,
+                              uint8_t N_ap,
+                              const int32_t srs_estimated_channel_time[N_ap][ofdm_symbol_size]);
+
+int nr_est_toa_ns_srs(NR_DL_FRAME_PARMS *frame_parms,
+                      uint8_t N_arx,
+                      uint8_t N_ap,
+                      uint8_t N_symb_srs,
+                      int32_t srs_estimated_channel_freq[N_arx][N_ap][frame_parms->ofdm_symbol_size * N_symb_srs],
+                      int16_t *srs_toa_ns);
 
 void nr_pusch_ptrs_processing(PHY_VARS_gNB *gNB,
                               NR_DL_FRAME_PARMS *frame_parms,

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -982,21 +982,23 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx)
           srs_est = -1;
         }
 
-        T(T_GNB_PHY_UL_FREQ_CHANNEL_ESTIMATE,
-          T_INT(0),
-          T_INT(srs_pdu->rnti),
-          T_INT(frame_rx),
-          T_INT(0),
-          T_INT(0),
-          T_BUFFER(srs_estimated_channel_freq[0][0], frame_parms->ofdm_symbol_size * sizeof(int32_t)));
+        for (int ant_rx = 0; ant_rx < gNB->frame_parms.nb_antennas_rx; ant_rx++) {
+          T(T_GNB_PHY_UL_FREQ_CHANNEL_ESTIMATE,
+            T_INT(gNB->Mod_id),
+            T_INT(srs_pdu->rnti),
+            T_INT(frame_rx),
+            T_INT(slot_rx),
+            T_INT(ant_rx),
+            T_BUFFER(srs_estimated_channel_freq[ant_rx][0], (N_symb_SRS * frame_parms->ofdm_symbol_size) * sizeof(int32_t)));
 
-        T(T_GNB_PHY_UL_TIME_CHANNEL_ESTIMATE,
-          T_INT(0),
-          T_INT(srs_pdu->rnti),
-          T_INT(frame_rx),
-          T_INT(0),
-          T_INT(0),
-          T_BUFFER(srs_estimated_channel_time_shifted[0][0], frame_parms->ofdm_symbol_size * sizeof(int32_t)));
+          T(T_GNB_PHY_UL_TIME_CHANNEL_ESTIMATE,
+            T_INT(gNB->Mod_id),
+            T_INT(srs_pdu->rnti),
+            T_INT(frame_rx),
+            T_INT(slot_rx),
+            T_INT(ant_rx),
+            T_BUFFER(srs_estimated_channel_time_shifted[ant_rx][0], frame_parms->ofdm_symbol_size * sizeof(int32_t)));
+        }
 
         gNB->UL_INFO.srs_ind.pdu_list = &gNB->srs_pdu_list[0];
         gNB->UL_INFO.srs_ind.sfn = frame_rx;
@@ -1005,10 +1007,26 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx)
         nfapi_nr_srs_indication_pdu_t *srs_indication = &gNB->srs_pdu_list[gNB->UL_INFO.srs_ind.number_of_pdus];
         srs_indication->handle = srs_pdu->handle;
         srs_indication->rnti = srs_pdu->rnti;
+
+        uint8_t N_ap = 1 << srs_pdu->num_ant_ports;
+        uint8_t N_ant_rx = gNB->frame_parms.nb_antennas_rx;
+        int16_t srs_toa_ns[N_ant_rx];
+        // call ToA estimation function
+        nr_est_toa_ns_srs(frame_parms, N_ant_rx, N_ap, N_symb_SRS, srs_estimated_channel_freq, srs_toa_ns);
+
         start_meas(&gNB->srs_timing_advance_stats);
-        srs_indication->timing_advance_offset = srs_est >= 0 ? nr_est_timing_advance_srs(frame_parms, srs_estimated_channel_time[0]) : 0xFFFF;
+        srs_indication->timing_advance_offset =
+            srs_est >= 0 ? nr_est_timing_advance_srs(frame_parms->ofdm_symbol_size, N_ap, srs_estimated_channel_time[0]) : 0xFFFF;
         stop_meas(&gNB->srs_timing_advance_stats);
-        srs_indication->timing_advance_offset_nsec = srs_est >= 0 ? (int16_t)((((int32_t)srs_indication->timing_advance_offset - 31) * ((int32_t)TC_NSEC_x32768)) >> 15) : 0xFFFF;
+        srs_indication->timing_advance_offset_nsec = srs_est >= 0 ? srs_toa_ns[0] : 0xFFFF;
+
+        T(T_GNB_PHY_UL_SRS_TOA_NS,
+          T_INT(gNB->Mod_id),
+          T_INT(srs_pdu->rnti),
+          T_INT(frame_rx),
+          T_INT(slot_rx),
+          T_BUFFER(srs_toa_ns, N_ant_rx * sizeof(int32_t)));
+
         switch (srs_pdu->srs_parameters_v4.usage) {
           case 0:
             LOG_W(NR_PHY, "SRS report was not requested by MAC\n");