lte_adjust_sync.c 8.29 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/*
 * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The OpenAirInterface Software Alliance licenses this file to You under
 * the OAI Public License, Version 1.0  (the "License"); you may not use this file
 * except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.openairinterface.org/?page_id=698
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *-------------------------------------------------------------------------------
 * For more information about the OpenAirInterface (OAI) Software Alliance:
 *      contact@openairinterface.org
 */

22 23 24 25
#include "PHY/types.h"
#include "PHY/defs.h"
#include "PHY/extern.h"

26 27
#include "UTIL/LOG/vcd_signal_dumper.h"

28
#define DEBUG_PHY
29 30 31 32 33 34

// Adjust location synchronization point to account for drift
// The adjustment is performed once per frame based on the
// last channel estimate of the receiver

void lte_adjust_synch(LTE_DL_FRAME_PARMS *frame_parms,
35
                      PHY_VARS_UE *ue,
36
                      unsigned char eNB_id,
37
					  uint8_t subframe,
38 39
                      unsigned char clear,
                      short coef)
40 41 42
{

  static int max_pos_fil = 0;
43 44
  static int count_max_pos_ok = 0;
  static int first_time = 1;
45
  int temp = 0, i, aa, max_val = 0, max_pos = 0;
46 47 48
  int diff;
  short Re,Im,ncoef;

49 50
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ADJUST_SYNCH, VCD_FUNCTION_IN);

51 52 53
  ncoef = 32767 - coef;

#ifdef DEBUG_PHY
54
  LOG_D(PHY,"AbsSubframe %d.%d: rx_offset (before) = %d\n",ue->proc.proc_rxtx[0].frame_rx%1024,subframe,ue->rx_offset);
55 56 57 58 59 60
#endif //DEBUG_PHY


  // we only use channel estimates from tx antenna 0 here
  for (i = 0; i < frame_parms->nb_prefix_samples; i++) {
    temp = 0;
61 62

    for (aa=0; aa<frame_parms->nb_antennas_rx; aa++) {
63 64
      Re = ((int16_t*)ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates_time[eNB_id][aa])[(i<<2)];
      Im = ((int16_t*)ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates_time[eNB_id][aa])[1+(i<<2)];
65 66
      temp += (Re*Re/2) + (Im*Im/2);
    }
67

68 69 70 71 72 73 74 75 76 77 78 79
    if (temp > max_val) {
      max_pos = i;
      max_val = temp;
    }
  }

  // filter position to reduce jitter
  if (clear == 1)
    max_pos_fil = max_pos;
  else
    max_pos_fil = ((max_pos_fil * coef) + (max_pos * ncoef)) >> 15;

80
  // do not filter to have proactive timing adjustment
81
  max_pos_fil = max_pos;
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134

  if(subframe == 6)
  {
      diff = max_pos_fil - (frame_parms->nb_prefix_samples>>3);

      if ( abs(diff) < SYNCH_HYST )
          ue->rx_offset = 0;
      else
          ue->rx_offset = diff;

      if(abs(diff)<5)
          count_max_pos_ok ++;
      else
          count_max_pos_ok = 0;

      if(count_max_pos_ok > 10 && first_time == 1)
      {
          first_time = 0;
          ue->time_sync_cell = 1;
          if (ue->mac_enabled==1) {
              LOG_I(PHY,"[UE%d] Sending synch status to higher layers\n",ue->Mod_id);
              //mac_resynch();
              mac_xface->dl_phy_sync_success(ue->Mod_id,ue->proc.proc_rxtx[0].frame_rx,0,1);//ue->common_vars.eNb_id);
              ue->UE_mode[0] = PRACH;
          }
          else {
              ue->UE_mode[0] = PUSCH;
          }
      }

      if ( ue->rx_offset < 0 )
          ue->rx_offset += FRAME_LENGTH_COMPLEX_SAMPLES;

      if ( ue->rx_offset >= FRAME_LENGTH_COMPLEX_SAMPLES )
          ue->rx_offset -= FRAME_LENGTH_COMPLEX_SAMPLES;



      #ifdef DEBUG_PHY
      LOG_D(PHY,"AbsSubframe %d.%d: diff =%i rx_offset (final) = %i : clear %d,max_pos = %d,max_pos_fil = %d (peak %d) max_val %d target_pos %d \n",
              ue->proc.proc_rxtx[subframe%RX_NB_TH].frame_rx,
              subframe,
              diff,
              ue->rx_offset,
              clear,
              max_pos,
              max_pos_fil,
              temp,max_val,
              (frame_parms->nb_prefix_samples>>3));
      #endif //DEBUG_PHY

      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ADJUST_SYNCH, VCD_FUNCTION_OUT);
  }
135 136 137 138
}


int lte_est_timing_advance(LTE_DL_FRAME_PARMS *frame_parms,
139
                           LTE_eNB_SRS *lte_eNB_srs,
140 141 142 143
                           unsigned int  *eNB_id,
                           unsigned char clear,
                           unsigned char number_of_cards,
                           short coef)
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158

{

  static int max_pos_fil2 = 0;
  int temp, i, aa, max_pos = 0,ind;
  int max_val=0;
  short Re,Im,ncoef;
#ifdef USER_MODE
#ifdef DEBUG_PHY
  char fname[100],vname[100];
#endif
#endif

  ncoef = 32768 - coef;

159
  for (ind=0; ind<number_of_cards; ind++) {
160 161 162 163 164

    if (ind==0)
      max_val=0;


165
    for (aa=0; aa<frame_parms->nb_antennas_rx; aa++) {
166
      // do ifft of channel estimate
167 168
      switch(frame_parms->N_RB_DL) {
      case 6:
169 170
	dft128((int16_t*) &lte_eNB_srs->srs_ch_estimates[ind][aa][0],
	       (int16_t*) lte_eNB_srs->srs_ch_estimates_time[ind][aa],
171 172 173
	       1);
	break;
      case 25:
174 175
	dft512((int16_t*) &lte_eNB_srs->srs_ch_estimates[ind][aa][0],
	       (int16_t*) lte_eNB_srs->srs_ch_estimates_time[ind][aa],
176 177 178
	       1);
	break;
      case 50:
179 180
	dft1024((int16_t*) &lte_eNB_srs->srs_ch_estimates[ind][aa][0],
		(int16_t*) lte_eNB_srs->srs_ch_estimates_time[ind][aa],
181 182 183
		1);
	break;
      case 100:
184 185
	dft2048((int16_t*) &lte_eNB_srs->srs_ch_estimates[ind][aa][0],
	       (int16_t*) lte_eNB_srs->srs_ch_estimates_time[ind][aa],
186 187 188
	       1);
	break;
      }
189 190 191 192
#ifdef USER_MODE
#ifdef DEBUG_PHY
      sprintf(fname,"srs_ch_estimates_time_%d%d.m",ind,aa);
      sprintf(vname,"srs_time_%d%d",ind,aa);
193
      write_output(fname,vname,lte_eNB_srs->srs_ch_estimates_time[ind][aa],frame_parms->ofdm_symbol_size*2,2,1);
194 195 196 197 198 199 200 201
#endif
#endif
    }

    // we only use channel estimates from tx antenna 0 here
    // remember we fixed the SRS to use only every second subcarriers
    for (i = 0; i < frame_parms->ofdm_symbol_size/2; i++) {
      temp = 0;
202 203

      for (aa=0; aa<frame_parms->nb_antennas_rx; aa++) {
204 205
        Re = ((int16_t*)lte_eNB_srs->srs_ch_estimates_time[ind][aa])[(i<<1)];
        Im = ((int16_t*)lte_eNB_srs->srs_ch_estimates_time[ind][aa])[1+(i<<1)];
206
        temp += (Re*Re/2) + (Im*Im/2);
207
      }
208

209
      if (temp > max_val) {
210 211 212
        max_pos = i;
        max_val = temp;
        *eNB_id = ind;
213 214 215 216 217 218 219 220 221
      }
    }
  }

  // filter position to reduce jitter
  if (clear == 1)
    max_pos_fil2 = max_pos;
  else
    max_pos_fil2 = ((max_pos_fil2 * coef) + (max_pos * ncoef)) >> 15;
222

223 224 225
#ifdef DEBUG_PHY
  //LOG_D(PHY,"frame %d: max_pos = %d, max_pos_fil = %d\n",mac_xface->frame,max_pos,max_pos_fil2);
#endif //DEBUG_PHY
226

227 228 229 230
  return(max_pos_fil2);
}


231
int lte_est_timing_advance_pusch(PHY_VARS_eNB* eNB,uint8_t UE_id)
232 233 234 235 236 237 238
{
  static int first_run=1;
  static int max_pos_fil2=0;
  int temp, i, aa, max_pos=0, max_val=0;
  short Re,Im,coef=24576;
  short ncoef = 32768 - coef;

239 240
  LTE_DL_FRAME_PARMS *frame_parms = &eNB->frame_parms;
  LTE_eNB_PUSCH *eNB_pusch_vars = eNB->pusch_vars[UE_id];
241
  int32_t **ul_ch_estimates_time=  eNB_pusch_vars->drs_ch_estimates_time[0];
242
  uint8_t cyclic_shift = 0;
243
  int sync_pos = (frame_parms->ofdm_symbol_size-cyclic_shift*frame_parms->ofdm_symbol_size/12)%(frame_parms->ofdm_symbol_size);
244 245 246


  for (i = 0; i < frame_parms->ofdm_symbol_size; i++) {
247 248 249
    temp = 0;

    for (aa=0; aa<frame_parms->nb_antennas_rx; aa++) {
250 251
      Re = ((int16_t*)ul_ch_estimates_time[aa])[(i<<1)];
      Im = ((int16_t*)ul_ch_estimates_time[aa])[1+(i<<1)];
252 253 254 255 256 257 258
      temp += (Re*Re/2) + (Im*Im/2);
    }

    if (temp > max_val) {
      max_pos = i;
      max_val = temp;
    }
259 260
  }

261 262
  if (max_pos>frame_parms->ofdm_symbol_size/2)
    max_pos = max_pos-frame_parms->ofdm_symbol_size;
263 264

  // filter position to reduce jitter
265
  if (first_run == 1) {
266 267
    first_run=0;
    max_pos_fil2 = max_pos;
268
  } else
269
    max_pos_fil2 = ((max_pos_fil2 * coef) + (max_pos * ncoef)) >> 15;
270

271
#ifdef DEBUG_PHY
272
  LOG_D(PHY,"frame %d: max_pos = %d, max_pos_fil = %d, sync_pos=%d\n",eNB->proc.frame_rx,max_pos,max_pos_fil2,sync_pos);
273 274 275 276
#endif //DEBUG_PHY

  return(max_pos_fil2-sync_pos);
}