Use CP-based CFO estimation only for DL and UL. Estimate every subframe. Calibrated EMA to 0.3 highest valid for low SNR

lib/include/srslte/phy/sync/sync.h

@@ -139,6 +139,10 @@ SRSLTE_API srslte_sync_find_ret_t srslte_sync_find(srslte_sync_t *q,
                                                    uint32_t find_offset,
                                                    uint32_t *peak_position);
 
+SRSLTE_API float srslte_sync_cfo_estimate(srslte_sync_t *q,
+                                          cf_t *input,
+                                          int find_offset);
+
 /* Estimates the CP length */
 SRSLTE_API srslte_cp_t srslte_sync_detect_cp(srslte_sync_t *q, 
                                              cf_t *input, 

lib/include/srslte/phy/ue/ue_sync.h

@@ -88,7 +88,12 @@ typedef struct SRSLTE_API {
   bool file_mode; 
   float file_cfo; 
   srslte_cfo_t file_cfo_correct; 
-  
+
+  bool  mean_cfo_isunset;
+  float cfo;
+  float mean_cfo;
+  float cfo_ema_alpha;
+
   srslte_ue_sync_state_t state;
   
   uint32_t frame_len; 

lib/src/phy/sync/sync.c

@@ -587,19 +587,21 @@ srslte_sync_find_ret_t srslte_sync_find(srslte_sync_t *q, cf_t *input, uint32_t
           DEBUG("Not enough room to detect CP length. Peak position: %d\n", peak_pos);
         }
       }
-  
-      if (peak_pos + find_offset >= 2*(q->fft_size + SRSLTE_CP_LEN_EXT(q->fft_size))) {
-        float cfo2   = srslte_pss_synch_cfo_compute(&q->pss, &input[find_offset + peak_pos - q->fft_size]);
-        if (q->mean_cfo2_isunset) {
-          q->mean_cfo2 = cfo2;
-          q->mean_cfo2_isunset = true;
+
+      if (q->enable_cfo_corr) {
+        if (peak_pos + find_offset >= 2*(q->fft_size + SRSLTE_CP_LEN_EXT(q->fft_size))) {
+          float cfo2   = srslte_pss_synch_cfo_compute(&q->pss, &input[find_offset + peak_pos - q->fft_size]);
+          if (q->mean_cfo2_isunset) {
+            q->mean_cfo2 = cfo2;
+            q->mean_cfo2_isunset = true;
+          } else {
+            q->mean_cfo2 = SRSLTE_VEC_EMA(cfo2, q->mean_cfo2, q->cfo_ema_alpha);
+          }
+
+          ret = SRSLTE_SYNC_FOUND;
         } else {
-          q->mean_cfo2 = SRSLTE_VEC_EMA(cfo2, q->mean_cfo2, q->cfo_ema_alpha);
+          ret = SRSLTE_SYNC_FOUND_NOSPACE;
         }
-
-        ret = SRSLTE_SYNC_FOUND;
-      } else {
-        ret = SRSLTE_SYNC_FOUND_NOSPACE; 
       }
     } else {
       ret = SRSLTE_SYNC_NOFOUND;

lib/src/phy/ue/ue_sync.c

@@ -47,6 +47,10 @@
 #define DEFAULT_SAMPLE_OFFSET_CORRECT_PERIOD  0
 #define DEFAULT_SFO_EMA_COEFF                 0.1
 
+
+//#define DO_CFO_IN_SYNC
+
+
 cf_t dummy_buffer0[15*2048/2];
 cf_t dummy_buffer1[15*2048/2];
 
@@ -182,6 +186,9 @@ int srslte_ue_sync_init_multi_decim(srslte_ue_sync_t *q,
     q->sample_offset_correct_period = DEFAULT_SAMPLE_OFFSET_CORRECT_PERIOD; 
     q->sfo_ema                      = DEFAULT_SFO_EMA_COEFF; 
 
+    q->mean_cfo_isunset = true;
+    q->mean_cfo         = 0;
+    q->cfo_ema_alpha    = 0.4;
     q->max_prb = max_prb;
 
     if (search_cell) {
@@ -218,6 +225,11 @@ int srslte_ue_sync_init_multi_decim(srslte_ue_sync_t *q,
       }
     }
 
+#ifndef DO_CFO_IN_SYNC
+    // Disable CFO correction in sync object and do it here every subframe
+    srslte_sync_set_cfo_enable(&q->strack, false);
+#endif
+
     ret = SRSLTE_SUCCESS;
   }
 
@@ -362,6 +374,7 @@ uint32_t srslte_ue_sync_peak_idx(srslte_ue_sync_t *q) {
 void srslte_ue_sync_set_cfo_ema(srslte_ue_sync_t *q, float ema) {
   srslte_sync_set_cfo_ema_alpha(&q->sfind, ema);
   srslte_sync_set_cfo_ema_alpha(&q->strack, ema);
+  q->cfo_ema_alpha = ema;
 }
 
 srslte_ue_sync_state_t srslte_ue_sync_get_state(srslte_ue_sync_t *q) {
@@ -377,7 +390,11 @@ void srslte_ue_sync_cfo_i_detec_en(srslte_ue_sync_t *q, bool enable) {
 }
 
 float srslte_ue_sync_get_cfo(srslte_ue_sync_t *q) {
+#ifdef DO_CFO_IN_SYNC
   return 15000 * srslte_sync_get_cfo(&q->strack);
+#else
+  return 15000 * q->mean_cfo;
+#endif
 }
 
 void srslte_ue_sync_set_cfo(srslte_ue_sync_t *q, float cfo) {  
@@ -662,6 +679,23 @@ int srslte_ue_sync_zerocopy_multi(srslte_ue_sync_t *q, cf_t *input_buffer[SRSLTE
           
           q->sf_idx = (q->sf_idx + q->nof_recv_sf) % 10;
 
+#ifndef DO_CFO_IN_SYNC
+          /* We found that CP-based correction performs better in low SNR than PSS-based.
+           *
+           * Estimate, average and correct here instead of inside sync object
+           */
+          q->cfo = srslte_sync_cfo_estimate(&q->strack, input_buffer[0], 0);
+          if (q->mean_cfo_isunset) {
+            q->mean_cfo = q->cfo;
+            q->mean_cfo_isunset = false;
+          } else {
+            /* compute exponential moving average CFO */
+            q->mean_cfo = SRSLTE_VEC_EMA(q->cfo, q->mean_cfo, q->cfo_ema_alpha);
+          }
+          srslte_cfo_correct(&q->strack.cfocorr2, input_buffer[0], input_buffer[0], -q->mean_cfo / q->fft_size);
+
+#endif
+
           /* Every SF idx 0 and 5, find peak around known position q->peak_idx */
           if (q->sf_idx == 0 || q->sf_idx == 5) {
 

srsue/src/main.cc

@@ -208,7 +208,7 @@ void parse_args(all_args_t *args, int argc, char *argv[]) {
      "Tolerance (in Hz) for digial CFO compensation.")
 
     ("expert.cfo_ema",
-     bpo::value<float>(&args->expert.phy.cfo_ema)->default_value(0.4),
+     bpo::value<float>(&args->expert.phy.cfo_ema)->default_value(0.3),
      "CFO Exponential Moving Average coefficient. Lower makes it more robust to noise "
      "but vulnerable to periodic interruptions due to VCO corrections.")
 

srsue/src/phy/phch_worker.cc

@@ -128,6 +128,7 @@ bool phch_worker::init(uint32_t max_prb, srslte::log *log_h)
 
   srslte_ue_ul_set_normalization(&ue_ul, true);
   srslte_ue_ul_set_cfo_enable(&ue_ul, true);
+  srslte_ue_ul_set_cfo_tol(&ue_ul, phy->args->cfo_correct_tol_hz);
 
   mem_initiated = true;
 

srsue/ue.conf.example

@@ -172,7 +172,7 @@ enable = false
 #attach_enable_64qam = false
 #nof_phy_threads     = 2
 #equalizer_mode      = mmse
-#cfo_ema             = 0.4
+#cfo_ema             = 0.3
 #cfo_integer_enabled = false
 #cfo_correct_tol_hz  = 50
 #time_correct_period = 5